多线程/多进程同步之Condition(生产者-消费者问题)

标准库模块threading中提供了一个类对象Condition，用于表示带触发条件的锁，以帮助我们处理多线程间复杂的同步问题。例如生产者消费者问题。
Condition被称为条件变量，除了提供与Lock类似的acquire和release方法外，还提供了wait和notify方法。
Condition允许一个或多个线程等待触发条件，直到收到另外一个线程的通知。使用Condition的主要方式为：线程首先acquire一个条件变量，然后判断一些条件。
如果条件不满足则wait；如果条件满足，进行一些处理改变条件后，通过notify方法通知其他线程，其他处于wait状态的线程接到通知后会重新判断条件。
不断的重复这一过程，从而解决复杂的同步问题。

•threading.Condition([lock])：创建一个condition，支持从外界引用一个Lock对象（适用于多个condtion共用一个Lock的情况），默认是创建一个新的Lock对象。

•acquire()/release()：获得/释放 Lock

•wait([timeout]):线程挂起，直到收到一个notify通知或者超时（可选的，浮点数，单位是秒s）才会被唤醒继续运行。wait()必须在已获得Lock前提下才能调用，
否则会触发RuntimeError。调用wait()会释放Lock，直至该线程被Notify()、NotifyAll()或者超时线程又重新获得Lock.

#调用wait后的4个动作
1，该线程被阻塞。
2，该线程被放到条件等待池。
3，释放锁。
4，开始等待；此时锁等待池中的某个线程将获得锁。

•notify(n=1):通知其他线程，那些挂起的线程接到这个通知之后会开始运行，默认是通知一个正等待该condition的线程,
最多则唤醒n个等待的线程。notify()必须在已获得Lock前提下才能调用，否则会触发RuntimeError。notify()不会主动释放Lock。
#调用notify后的两个处理
1，通知条件等待池中的线程。
2，被通知的线程自动调用方法acquire()试图获得锁。
•notifyAll(): 如果wait状态线程比较多，notifyAll的作用就是通知所有线程。

#【1】多线程同步之Condition

from threading import Thread, Condition
import time

cond = Condition()

class Thread1(Thread):
    def __init__(self, name):
        super().__init__(name=name)

    def run(self):
        cond.acquire()

        print('%s说：1' % self.name)
        cond.notify()    #
        cond.wait()
        #等待两秒
        time.sleep(2)
        print('%s说：11' % self.name)
        cond.notify()
        cond.wait()

        time.sleep(2)
        print('%s说：111' % self.name)
        cond.notify()

        cond.release()

class Thread2(Thread):
    def __init__(self, name):
        super().__init__(name=name)

    def run(self):
        time.sleep(1)
        cond.acquire()

        time.sleep(2)
        print('%s说：2' % self.name)
        cond.notify()
        cond.wait()

        time.sleep(2)
        print('%s说：22' % self.name)
        cond.notify()
        cond.wait()

        time.sleep(2)
        print('%s说：222' % self.name)

        cond.release()

Thread1('Thread1').start()
Thread2('Thread2').start()

Condition对象的构造函数可以接受一个Lock/RLock对象作为参数，如果没有指定，则Condition对象会在内部自行创建一个RLock；
除了notify方法外，Condition对象还提供了notifyAll方法，可以通知waiting池中的所有线程尝试acquire内部锁。
由于上述机制，处于waiting状态的线程只能通过notify方法唤醒，所以notifyAll的作用在于防止有线程永远处于沉默状态。

#【2】多进程同步之Condition

from multiprocessing import Process, Condition
import time

cond = Condition()

class MyProcess1(Process):
    def __init__(self, name):
        super().__init__(name=name)

    def run(self):
        cond.acquire()

        print('%s说：1' % self.name)
        cond.notify()
        cond.wait()

        # 等待2秒
        time.sleep(2)
        print('%s说：11' % self.name)
        cond.notify()
        cond.wait()

        time.sleep(2)
        print('%s说：111' % self.name)
        cond.notify()

        cond.release()

class MyProcess2(Process):
    def __init__(self, name):
        super().__init__(name=name)

    def run(self):
        time.sleep(1)
        cond.acquire()

        # 等待2秒
        time.sleep(2)
        print('%s说：2' % self.name)
        cond.notify()
        cond.wait()

        time.sleep(2)
        print('%s说：22' % self.name)
        cond.notify()
        cond.wait()

        time.sleep(2)
        print('%s说：222' % self.name)

        cond.release()

MyProcess1('Process1').start()
MyProcess2('Process2').start()

★生产者消费者问题

假设有一群生产者和一群消费者通过市场来交换产品。
生产者：如果市场上剩余的产品小于20个，就生产4个产品放到市场上。
消费者：如果市场上剩余的产品多余10个，那么就从市场上消费3个产品。

#【3】生产者消费者问题-多线程Condition

from threading import Thread, Condition
import time

cond = Condition()
count = 0

class Producer(Thread):
    def run(self):
        global count, cond
        while True:
            cond.acquire()
            if count < 20:
                count += 4
                print('%s：生产者生产了4个，当前总共%d个' % (self.name, count))
                cond.notify()
            else:
                print('%s：不生产，等待' % self.name)
                cond.wait()
            cond.release()
            time.sleep(2)

class Consumer(Thread):
    def run(self):
        global count, cond
        while True:
            cond.acquire()
            if count > 10:
                count -= 3
                print('%s：消费者消费了3个，当前总共%d个' % (self.name, count))
                cond.notify()
            else:
                print('%s：不消费，等待' % self.name)
                cond.wait()
            cond.release()
            time.sleep(2)

for i in range(3):
    Producer().start()

for i in range(3):
    Consumer().start()

#使用队列

import time,random
import queue,threading

q = queue.Queue()

def Producer(name):
  count = 0
  while count <20:
    print("开始生产")
    time.sleep(random.randrange(3))
    q.put(count)
    print('生产者 %s 已生产 %s ..' %(name, count))
    count +=1
    #q.task_done()#生产完毕，通知消费的q.join()，q.join()后面的语句才会被执行。
    #q.join()
    print("ok......")
def Consumer(name):
  count = 0
  while count <20:
    time.sleep(random.randrange(4))
    if not q.empty():
        data = q.get()
        #q.task_done()
        #q.join() #接收生产者q.task_done的通知，然后执行下面语句，否则，阻塞，等待通知。
        print('消费者 %s 已消费 %s ..' %(name, data))
    else:
        print("-----无剩余了----")
    count +=1

p1 = threading.Thread(target=Producer, args=('生产者1',))
c1 = threading.Thread(target=Consumer, args=('消费者1',))
c2 = threading.Thread(target=Consumer, args=('消费者2',))
c3 = threading.Thread(target=Consumer, args=('消费者3',))
p1.start()
c1.start()
c2.start()
c3.start()

#【4】生产者消费者问题-多进程Condition

from multiprocessing import Process, Value, Condition
import time

cond = Condition()
count = Value('i', 0)

class Producer(Process):
    def run(self):
        global count, cond
        while True:
            cond.acquire()
            if count.value < 20:
                count.value += 4
                print('%s：生产者生产了4个，当前总共%d个' % (self.name, count.value))
                cond.notify()
            else:
                print('%s：不生产，等待' % self.name)
                cond.wait()
            cond.release()
            time.sleep(2)

class Consumer(Process):
    def run(self):
        global count, cond
        while True:
            cond.acquire()
            if count.value > 10:
                count.value -= 3
                print('%s：消费者消费了3个，当前总共%d个' % (self.name, count.value))
                cond.notify()
            else:
                print('%s：不消费，等待' % self.name)
                cond.wait()
            cond.release()
            time.sleep(2)

for i in range(3):
    Producer().start()

for i in range(3):
    Consumer().start()