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

jrgf

　　为了学习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上面了