python生产者消费者_Python学习（三）：生产者-消费者

为了学习Python，最好还是直接从写代码入手，解决的问题如下：

1、设计三个线程，线程1每秒钟对一个值进行+1操作，线程2每秒钟对该值进行+3操作，线程3每秒钟对该值进行-2操作

涉及知识点：线程，锁，time标准库

代码如下：

#coding=utf-8

'''

Created on 2015年8月19日

设计三个线程，线程1每秒钟对一个值进行+1操作，线程2每秒钟对该值进行+3操作，线程3每秒钟对该值进行-2操作

@author: minmin

'''

import time

import thread

def loop(name, value, nsleep, action, lock1, lock2):

while True:

lock1.acquire()

value[0] += action

action_str = ""

if action >= 0:

action_str = "+" + str(action)

else:

action_str = str(action)

print name + "对value做了" + action_str + "操作， value = " + str(value[0])

lock1.release()

time.sleep(nsleep)

lock2.release()

def main():

lock = thread.allocate_lock()

lock1 = thread.allocate_lock()

lock2 = thread.allocate_lock()

lock3 = thread.allocate_lock()

value = [10]

lock1.acquire()

lock2.acquire()

lock3.acquire()

locks = [lock1, lock2, lock3]

thread.start_new_thread(loop, ("Producer1", value, 1, 1, lock, lock1))

thread.start_new_thread(loop, ("Producer2", value, 1, 3, lock, lock2))

thread.start_new_thread(loop, ("Customer1", value, 1, -2, lock, lock3))

#防止主线程执行完自动关闭运行的三个线程

for i in locks:

while i.locked(): pass

if __name__ == '__main__':

main()

运行结果如下图：

2、设计三个线程，两个生产者一个消费者：一个生产者每秒钟生产1一个产品放入产品池，一个生产者每秒钟生产2个产品放入产品池，一个消费者每秒钟从产品池中消费1-5之间的一个随机数个产品。产品池满时，生产者等待，产品池有空位时，生产者继续生产；产品池空时，消费者等待，产品池有产品时，消费者继续消费。每个产品有自己独特的标记。

涉及知识点：多线程、锁、threading、生产者-消费者、阻塞队列。

这里先实现一个线程的子模块myThread，方便调用函数。

代码如下：

#coding=utf-8

'''

Created on 2015年8月23日

@author: minmin

'''

import threading

import time

class MyThread(threading.Thread):

def __init__(self, func, args, name = ''):

threading.Thread.__init__(self)

self.func = func

self.args = args

self.name = name

def getResult(self):

return self.res

def run(self):

print 'starting %s at:%s' % (self.name, time.strftime('%Y-%m-%d %H:%M:%S'))

self.res = apply(self.func, self.args)

print '%s finished at:%s' % (self.name, time.strftime('%Y-%m-%d %H:%M:%S'))

生产者-消费者代码如下：

#coding=utf-8

'''

Created on 2015年8月23日

@author: minmin

'''

import random

import time

import myThread

import Queue

import threading

'''

生产者，每nsleep秒生产nprod个产品，放入queue中

a 产品标记

name 生产者的名字

'''

def producer(queue, nsleep, nprod, name, a, lock):

while True:

for i in range(nprod):

lock.acquire()

queue.put(a[0], 1)

print '%s生产了一个产品：%d, 当前队列大小：%d' % (name, a[0], queue.qsize())

a[0] += 1

lock.release()

time.sleep(nsleep)

'''

消费着，每nsleep秒从queue中消费minProd至maxProd间随机产生的一个值的产品

name 消费者的名字

'''

def consumer(queue, nsleep, minProd, maxProd, name):

while True:

nprod = random.randint(minProd, maxProd)

for i in range(nprod):

val = queue.get(1)

print '%s消费了一个产品：%d, 当前队列大小：%d' % (name, val, queue.qsize())

time.sleep(nsleep)

def main():

queue = Queue.Queue(10)

a = [0]

lock = threading.Lock()

producer1 = myThread.MyThread(producer, (queue, 1, 1, 'producer1', a, lock), 'producer1')

producer2 = myThread.MyThread(producer, (queue, 1, 2, 'producer2', a, lock), 'producer2')

consumer1 = myThread.MyThread(consumer, (queue, 1, 1, 5, 'consumer1'), 'consumer1')

threads = [producer1, producer2, consumer1]

for i in threads:

i.start()

for i in threads:

i.join()

if __name__ == '__main__':

main()

运行结果如下：

代码我也放到GitHub上面了