python:消费者与提供者问题

问题描述：

消费者消耗资源，提供者生产资源。

问题涉及：

队列、多线程

代码：

• 生产者多于消费者时：

from threading import Thread,current_thread
import time
import random
from queue import Queue


queue = Queue(5)   #定义队列的长度

#开启一个生产者的线程
class ProducerThread(Thread):
    def run(self):
        name = current_thread().getName()
        nums = range(100)
        global queue
        while True:
            num = random.choice(nums)
            queue.put(num)
            print('生产者 %s 生产了数据 %s' %(name,num))
            t = random.randint(1,3)
            time.sleep(t)
            print('生产者 %s 睡眠了 %s 秒' %(name,t))

#开启一个消费者的线程
class ConsumerThread(Thread):
    def run(self):
        name = current_thread().getName()
        global queue
        while True:
            num = queue.get()
            queue.task_done()
            print('消耗者 %s 消耗了数据 %s' % (name, num))
            t = random.randint(1, 5)
            time.sleep(t)
            print('消耗者 %s 睡眠了 %s 秒' % (name, t))

#线程调用
p1 = ProducerThread(name = 'p1')
p1.start()
p2 = ProducerThread(name = 'p2')
p2.start()
p3 = ProducerThread(name = 'p3')
p3.start()
c1 = ConsumerThread(name = 'c1')
c1.start()
c2 = ConsumerThread(name = 'c2')
c2.start()

输出：

生产者 p1 生产了数据 87
生产者 p2 生产了数据 1
生产者 p3 生产了数据 60
消耗者 c1 消耗了数据 87
消耗者 c2 消耗了数据 1
生产者 p1 睡眠了 1 秒
生产者 p1 生产了数据 65
生产者 p2 睡眠了 2 秒消耗者 c2 睡眠了 2 秒
消耗者 c2 消耗了数据 60

生产者 p2 生产了数据 72
生产者 p3 睡眠了 3 秒
生产者 p3 生产了数据 76
生产者 p1 睡眠了 3 秒
生产者 p1 生产了数据 48
生产者 p2 睡眠了 2 秒消耗者 c2 睡眠了 2 秒

消耗者 c2 消耗了数据 65
生产者 p2 生产了数据 88
消耗者 c1 睡眠了 5 秒
消耗者 c1 消耗了数据 72
生产者 p2 睡眠了 1 秒
生产者 p2 生产了数据 99
生产者 p3 睡眠了 3 秒
生产者 p3 生产了数据 13
生产者 p1 睡眠了 2 秒
消耗者 c2 睡眠了 3 秒
消耗者 c2 消耗了数据 76生产者 p1 生产了数据 5

解析：

生产者数据比消耗数据快，当队列中数据满了以后，生产者不再生产数据，只有等消耗着消耗掉一些数据后，生产者再生产。

 

• 消耗者多于生产者时

from threading import Thread,current_thread
import time
import random
from queue import Queue


queue = Queue(5)   #定义队列的长度

#开启一个生产者的线程
class ProducerThread(Thread):
    def run(self):
        name = current_thread().getName()
        nums = range(100)
        global queue
        while True:
            num = random.choice(nums)
            queue.put(num)
            print('生产者 %s 生产了数据 %s' %(name,num))
            t = random.randint(1,3)
            time.sleep(t)
            print('生产者 %s 睡眠了 %s 秒' %(name,t))

#开启一个消费者的线程
class ConsumerThread(Thread):
    def run(self):
        name = current_thread().getName()
        global queue
        while True:
            num = queue.get()
            queue.task_done()
            print('消耗者 %s 消耗了数据 %s' % (name, num))
            t = random.randint(1, 5)
            time.sleep(t)
            print('消耗者 %s 睡眠了 %s 秒' % (name, t))

#线程调用
p1 = ProducerThread(name = 'p1')
p1.start()
c1 = ConsumerThread(name = 'c1')
c1.start()
c2 = ConsumerThread(name = 'c2')
c2.start()

运行结果：

生产者 p1 生产了数据 22
消耗者 c1 消耗了数据 22
生产者 p1 睡眠了 1 秒
生产者 p1 生产了数据 46消耗者 c2 消耗了数据 46

生产者 p1 睡眠了 1 秒
生产者 p1 生产了数据 68
消耗者 c1 睡眠了 3 秒
消耗者 c1 消耗了数据 68
生产者 p1 睡眠了 1 秒
生产者 p1 生产了数据 99
消耗者 c2 睡眠了 3 秒
消耗者 c2 消耗了数据 99
消耗者 c2 睡眠了 1 秒
生产者 p1 睡眠了 2 秒
生产者 p1 生产了数据 89消耗者 c2 消耗了数据 89

消耗者 c1 睡眠了 4 秒
消耗者 c2 睡眠了 2 秒生产者 p1 睡眠了 2 秒
生产者 p1 生产了数据 70
消耗者 c2 消耗了数据 70

消耗者 c2 睡眠了 1 秒生产者 p1 睡眠了 1 秒

生产者 p1 生产了数据 54消耗者 c1 消耗了数据 54

解析：

生产数据速度比消耗数据速度慢，所以消耗者轮流消耗数据。

 

涉及到的模块及函数解释：

模块 'threading' 是涉及多线程处理的模块，

          函数‘current_thread()'获取当前线程的一些信息，比如’current_thread().getName()‘获取当前线程的名称；

          ’Thread‘用于创建新的线程。

模块’time'是涉及时间的模块，

          函数‘sleep(t)'的功能是让程序休息 t 秒；

模块'random'是产生随机数的模块，

          函数'random.randint(1,5)'的功能是产生1~5之间的随机整数；

模块'queue' 是与队列相关的模块，

          函数’Queue(n)‘，是产生一个队列长度为 n 的队列；

          函数’put(x)‘, 是将元素 x 放入队列；

          函数'get()', 是取出队列中的一个元素（FIFO);

          函数’task_done()‘, 中完成了线程等待的功能。（待深入理解）

 

我的问题：

生产者和消费者程序的运行情况没什么问题，不过为什么输出的程序中，有的输出进行了换行，有的输出却木有，百思不得其解。

 

如有看到的人知道原因的，求赐教啊！！