代码:
# -*- coding: utf-8 -*- """ 学习线程同步，使用条件变量 逻辑: 生产消费者模型 一个有3个大小的产品库，一个生产者负责生产，一个消费者负责消费 每次生产或消费一个产品,产品库满了,生产者必须等待,产品库空了,消费者必须等待 生产者的速度是消费者的速度2倍，先启动消费者，一段时间后启动生产者 总结： 1. 条件变量底层用到R锁，对于已经获得锁的线程可以执行多次 acquire()，锁多次 2. 不确定是否和java的这一套 ，原理一样 使用： 1. 创建条件对象 cond = threading.Condition() 2. 在子线程调用 申请获取锁 cond.acquire() 3. 在程序中如果有必要 使用 cond.wait() cond.notify() cond.notifyall() 4. 使用完后 释放锁 cond.release() 参考： """ import threading import time class Goods: """ 记录产品数，最多3个产品 被多线程操作 """ def __init__(self): self.count = 0 def add(self,num = 1): self.count += num def sub(self): if self.count>=0: self.count -= 1 def empty(self): return self.count <= 0 def full(self): return self.count >= 3 class Producer(threading.Thread): """ 生产者 """ def __init__(self,condition,goods,name, sleeptime=1): threading.Thread.__init__(self) self.cond = condition self.goods = goods self.sleeptime = sleeptime self.name = name def run(self): cond = self.cond goods = self.goods while True: print "p1" cond.acquire() # 获取锁 print "p2" while goods.full(): # 如果产品满了 print "p3" cond.wait() print cond._Condition__lock print "p4" print "p5" goods.add() print("num:",goods.count,"producer") cond.notifyAll() # 唤醒所有等待的线程,并没有交出锁 print cond._Condition__lock # 锁还在 print "p6" cond.release() # 解锁资源 print cond._Condition__lock # 锁不在了 print "p7" time.sleep(self.sleeptime) class Consumer(threading.Thread): """ 消费者 """ def __init__(self,condition,goods,name, sleeptime=2): threading.Thread.__init__(self) self.cond = condition self.goods = goods self.sleeptime = sleeptime self.name = name def run(self): cond = self.cond goods = self.goods while True: print "c1" cond.acquire() # 获取锁 print "c2" while goods.empty(): # 如果没有产品了 print "c3" cond.wait() # 执行它，交出锁，进入等待池，然后阻塞，直到被唤醒 print cond._Condition__lock # 执行到这里，继续获得了锁 print "c4" print "c5" goods.sub() print("num:",goods.count, "consumer") cond.notifyAll() # 唤醒所有等待的线程,并没有交出锁 print cond._Condition__lock # 锁还在 print "c6" cond.release() # 解锁资源 print cond._Condition__lock # 锁不在了 print "c7" time.sleep(self.sleeptime) if __name__ == '__main__': g = Goods() # 共享数据 cond = threading.Condition() # 条件判断 # 启动消费者 consumer = Consumer(cond,g, name="consumer") consumer.start() # 2秒后启动生产者 time.sleep(2) print "m1" # 启动生产者 producer = Producer(cond,g, name="producer") producer.start() print "m2"
2 输出：
D:ProgramsAnacondapython.exe D:/1_practice/python/projects/downloads_modify/归类/并发/thread_sync_5.py c1 c2 c3 m1 p1m2 p2 p5 ('num:', 1, 'producer') <_RLock owner='producer' count=1> p6 <_RLock owner=None count=0><_RLock owner='consumer' count=1> p7c4 c5 ('num:', 0, 'consumer') <_RLock owner='consumer' count=1> c6 <_RLock owner=None count=0> c7 p1 p2 p5 ('num:', 1, 'producer') <_RLock owner='producer' count=1> p6 <_RLock owner=None count=0> p7 p1 p2 p5 ('num:', 2, 'producer') <_RLock owner='producer' count=1> p6 <_RLock owner=None count=0> p7 c1 c2 c5 ('num:', 1, 'consumer') <_RLock owner='consumer' count=1> c6 <_RLock owner=None count=0> c7 p1 p2 p5 ('num:', 2, 'producer') <_RLock owner='producer' count=1> p6 <_RLock owner=None count=0> p7 p1 p2 p5 ('num:', 3, 'producer') <_RLock owner='producer' count=1> p6 <_RLock owner=None count=0> p7 c1 c2 c5 ('num:', 2, 'consumer') <_RLock owner='consumer' count=1> c6 <_RLock owner=None count=0> c7 p1 p2 p5 ('num:', 3, 'producer') <_RLock owner='producer' count=1> p6 <_RLock owner=None count=0> p7 p1 p2 p3 c1 c2 c5 ('num:', 2, 'consumer') <_RLock owner='consumer' count=1> c6 <_RLock owner=None count=0><_RLock owner='producer' count=1> c7p4 p5 ('num:', 3, 'producer') <_RLock owner='producer' count=1> p6 <_RLock owner=None count=0> p7 p1 p2 p3 c1 c2 c5 ('num:', 2, 'consumer') <_RLock owner='consumer' count=1> c6 <_RLock owner=None count=0><_RLock owner='producer' count=1> c7p4 p5 ('num:', 3, 'producer') <_RLock owner='producer' count=1> p6 <_RLock owner=None count=0> p7 p1 p2 p3 c1 c2 c5 ('num:', 2, 'consumer') <_RLock owner='consumer' count=1> c6 <_RLock owner='producer' count=1><_RLock owner=None count=1> p4c7 p5 ('num:', 3, 'producer') <_RLock owner='producer' count=1> p6 <_RLock owner=None count=0> p7 p1 p2 p3 c1 c2 c5 ('num:', 2, 'consumer') <_RLock owner='consumer' count=1> c6 <_RLock owner=None count=0><_RLock owner='producer' count=1> c7p4 p5 ('num:', 3, 'producer') <_RLock owner='producer' count=1> p6 <_RLock owner=None count=0> p7 p1 p2 p3 c1 c2 c5 ('num:', 2, 'consumer') <_RLock owner='consumer' count=1> c6 <_RLock owner=None count=0><_RLock owner='producer' count=1> c7p4 p5 ('num:', 3, 'producer') <_RLock owner='producer' count=1> p6 <_RLock owner=None count=0> p7 p1 p2 p3 c1 c2 c5 ('num:', 2, 'consumer') <_RLock owner='consumer' count=1> c6 <_RLock owner=None count=0> c7<_RLock owner='producer' count=1> p4 p5 ('num:', 3, 'producer') <_RLock owner='producer' count=1> p6 <_RLock owner=None count=0> p7 p1 p2 p3 c1 c2 c5 ('num:', 2, 'consumer') <_RLock owner='consumer' count=1> c6 <_RLock owner=None count=0><_RLock owner='producer' count=1> c7p4 p5 ('num:', 3, 'producer') <_RLock owner='producer' count=1> p6 <_RLock owner=None count=0> p7 Process finished with exit code -1
3 输出解读：
4 相关资料
java中的notify和notifyAll有什么区别？
先说两个概念：锁池和等待池
- 锁池:假设线程A已经拥有了某个对象(注意:不是类)的锁，而其它的线程想要调用这个对象的某个synchronized方法(或者synchronized块)，由于这些线程在进入对象的synchronized方法之前必须先获得该对象的锁的拥有权，但是该对象的锁目前正被线程A拥有，所以这些线程就进入了该对象的锁池中。
- 等待池:假设一个线程A调用了某个对象的wait()方法，线程A就会释放该对象的锁后，进入到了该对象的等待池中
Reference：java中的锁池和等待池
链接：https://www.zhihu.com/question/37601861/answer/145545371
然后再来说notify和notifyAll的区别
- 如果线程调用了对象的 wait()方法，那么线程便会处于该对象的等待池中，等待池中的线程不会去竞争该对象的锁。
- 当有线程调用了对象的 notifyAll()方法（唤醒所有 wait 线程）或 notify()方法（只随机唤醒一个 wait 线程），被唤醒的的线程便会进入该对象的锁池中，锁池中的线程会去竞争该对象锁。也就是说，调用了notify后只要一个线程会由等待池进入锁池，而notifyAll会将该对象等待池内的所有线程移动到锁池中，等待锁竞争
- 优先级高的线程竞争到对象锁的概率大，假若某线程没有竞争到该对象锁，它还会留在锁池中，唯有线程再次调用 wait()方法，它才会重新回到等待池中。而竞争到对象锁的线程则继续往下执行，直到执行完了 synchronized 代码块，它会释放掉该对象锁，这时锁池中的线程会继续竞争该对象锁。
Reference：线程间协作：wait、notify、notifyAll
综上，所谓唤醒线程，另一种解释可以说是将线程由等待池移动到锁池，notifyAll调用后，会将全部线程由等待池移到锁池，然后参与锁的竞争，竞争成功则继续执行，如果不成功则留在锁池等待锁被释放后再次参与竞争。而notify只会唤醒一个线程。
有了这些理论基础，后面的notify可能会导致死锁，而notifyAll则不会的例子也就好解释了
