Python的condition和阻塞队

python的condition和阻塞队列Queue

条件（Condition）

条件同步机制是指：一个线程等待特定条件，而另一个线程发出特定条件满足的信号。 解释条件同步机制的一个很好的例子就是生产者/消费者（producer/consumer）模型。生产者随机的往列表中“生产”一个随机整数，而消费者从列表中“消费”整数。

实例：

#!/usr/bin/env Python
# -*- coding: utf-8 -*-
# @Time    : 2017/7/25 9:40
# @File    : produ.py
import random
import threading

import time




#生产者
class Producer(threading.Thread):

    def __init__(self,integers,condition,name):

        """
        构造器
        @:param integers 整数列表
        @:param condition 条件同步对象
        @:param name 线程名字
        """
        threading.Thread.__init__(self)
        self.integers = integers
        self.condition = condition
        self.name = name



    def run(self):
        """
        向队列中随机添加数字
        :return:
        """
        while True:
            integer = random.randint(0,300)
            self.condition.acquire()     #获取锁
            print '锁被',self.name,'拿了'
            self.integers.append(integer)   #加入列表
            print integer,'被',self.name,'加入列表'
            print '锁 被',self.name,'唤醒'
            self.condition.notify()
            print '锁被',self.name,'释放'
            self.condition.release()
            time.sleep(1)


#消费者
class Consumer(threading.Thread):
    def __init__(self,integers,condition,name):
        threading.Thread.__init__(self)
        self.integers = integers
        self.condition = condition
        self.name = name



    def run(self):
        while True:
            self.condition.acquire()
            print '锁被',self.name,'拿了'
            while True:
                if self.integers:
                    integer = self.integers.pop()
                    print integer,'从列表中被',self.name,'移除'
                    break

            print self.name,'等待'
            self.condition.wait()
            print '锁被',self.name,'释放'
            self.condition.release()


def main():
    integers = []
    condition = threading.Condition()
    consumer =  Consumer(integers,condition,'消费者')
    producer = Producer(integers,condition,'生产者')
    producer.start()
    consumer.start()
    producer.join()
    consumer.join()
    if __name__ == '__main__':
        main()


main()

队列（Queue）

队列是一个非常好的线程同步机制，使用队列我们不用关心锁，队列会为我们处理锁的问题。 队列(Queue)有以下4个用户感兴趣的方法：

put: 向队列中添加一个项；

get: 从队列中删除并返回一个项；

task_done: 当某一项任务完成时调用；

join: 阻塞知道所有的项目都被处理完。

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2017/7/25 10:10
# @File    : que.py

#生产者消费者，阻塞队列实现



import random
from  Queue import  Queue
import  threading
import time


class Producer(threading.Thread):
    """
    @:param queue 阻塞队列
    @:param name 线程名字
    """
    def __init__(self,queue,name):
        threading.Thread.__init__(self)
        self.queue = queue
        self.name = name


    def run(self):
        while True:
            integer = random.randint(0,350)
            self.queue.put(integer)
            print self.name,'将',integer,'加入队列'
            time.sleep(6)



class Consumer(threading.Thread):
    def __init__(self,queue,name):
        threading.Thread.__init__(self)
        self.queue = queue
        self.name = name


    def run(self):
        while True:
            integer = self.queue.get()
            print self.name,'将',integer,'从队列中移除'
            self.queue.task_done()


def main():
    queue = Queue(32)
    consumer = Consumer(queue,'消费者')
    producer = Producer(queue,'生产者')
    producer.start()
    consumer.start()

    if __name__ == '__main__':
        main()

main()