多线程：经典的生产者和消费者问题

gzj137070928

# 队列queue用来存储数据，先进来的先出去（FIFO）当队列满了之后就不在存了，.get提取数据，.put获得数据
# 后面会接触到存储数据的栈，后进来的先出去(LIFO)，就像‘先穿袜子再穿鞋，而先脱鞋后脱袜子’的关系

1. from threading import Thread, current_thread
   
2. import time
   
3. import random
   
4. from queue import Queue
   
5. 
   
6. que = Queue(5)  # 储存5个数据的队列
   
7. 
   
8. 
   
9. class ProducerThread(Thread):
   
10.     def run(self):
    
11.         name = current_thread().getName()
    
12.         nums = range(100)
    
13.         global que
    
14.         while True:  # 死循环用来测试
    
15.             num = random.choice(nums)  # 获得0-99中的一个随机数
    
16.             que.put(num)  # 队列获得这个随机数
    
17.             print('生产者%s生产了数据%s' % (name, num))
    
18.             t = random.randint(1, 3)
    
19.             time.sleep(t)
    
20.             print('生产者%s--睡眠了%s秒' % (name, t))
    
21. 
    
22. 
    
23. class ConsumerThread(Thread):
    
24.     def run(self):
    
25.         name = current_thread().getName()
    
26.         global que
    
27.         while True:
    
28.             num = que.get()
    
29.             que.task_done()
    
30.             print('消费者%s消耗了数据%s' % (name, num))
    
31.             t = random.randint(1, 5)
    
32.             time.sleep(t)
    
33.             print('消费者%s--睡眠了%s秒' % (name, num))
    
34. 
    
35. 
    
36. p1 = ProducerThread(name='p1')
    
37. p1.start()  # 开始运行，不然程序无执行
    
38. c1 = ConsumerThread(name='c1')
    
39. c1.start()
    
40. c2 = ConsumerThread(name='c2')
    
41. c2.start()

复制代码