Python学习之路并发编程--信号量、事件、队列及生产消费模型

            import
             time,random

            from multiprocessing import Process,Semaphore

def singing(i,sem):
    ‘‘‘
    :param i: 随机生成20个数的值
    :param sem:生成的信号量
    :return:None
    ‘‘‘
    sem.acquire()#获得锁print(‘%s is coming ‘%i)
    time.sleep(random.randint(10,20))#随机在10秒至20秒中停顿print(‘%s is going out‘%i)
    sem.release()#释放锁if__name__ == ‘__main__‘:
    sem = Semaphore(4)#生成4个锁for i in range(20):
        p = Process(target=singing,args=(i,sem))
        p.start()

            #
             set 和 clear
            
#
                  分别用来修改一个事件的状态 True或者False
            
#
             is_set 用来查看一个事件的状态
            
#
             wait 是依据事件的状态来决定自己是否在wait处阻塞
            
#
                  False阻塞 True不阻塞
        

            import
             time

            import
             random

            from multiprocessing import Event,Process

def cars(e,i):
    ‘‘‘
    一个判断车是否通过的函数
    :param e: 传入一个事件
    :param i: 生成的车几
    :return: None
    ‘‘‘ifnot e.is_set():
        print(‘33[0;31;40mcar %s 在等待~33[0m‘%i)
        e.wait()
    print(‘33[32;40mcar %s 通过~33[0m‘%i)

def light(e):
    ‘‘‘
    控制红绿灯的切换
    :param e: 传入事件
    :return: None
    ‘‘‘while True:
        if e.is_set():
            e.clear()
            print(‘33[31m红灯亮了33[0m‘)
            time.sleep(3)
        else:
            e.set()
            print(‘33[32m绿灯亮了33[0m‘)
            time.sleep(5)

if__name__ == ‘__main__‘:
    e = Event()
    traffic = Process(target=light,args=(e,))
    traffic.start()
    time.sleep(1)
    for i in range(random.randint(5,10)):
        car = Process(target=cars,args=(e,i))
        car.start()
        time.sleep(random.randint(1,3))

            #
             put  当队列满的时候阻塞等待队列有空位置
            #
             get  当队列空的时候阻塞等待队列有数据
            #
             full empty 不完全准确
        

            import
             time

            import
             random

            from multiprocessing import Process,JoinableQueue


def producer(name,food,q):
    for i in range(4):
        time.sleep(random.randint(1,3))
        f = ‘%s生产了%s%s‘%(name,food,i)
        print(f)
        q.put(f)
    q.join()    # 阻塞  直到一个队列中的所有数据 全部被处理完毕def consumer(q,name):
    while True:
        food = q.get()
        print(‘33[31m%s消费了%s33[0m‘ % (name,food))
        time.sleep(random.randint(1,3))
        q.task_done()     # count - 1if__name__  == ‘__main__‘:
    q = JoinableQueue(20)
    p1 = Process(target=producer,args=(‘eli‘,‘dumpling‘,q))
    p2 = Process(target=producer, args=(‘tom‘,‘noodle‘, q))
    c1 = Process(target=consumer, args=(q,‘mike‘))
    c2 = Process(target=consumer, args=(q,‘johan‘))
    p1.start()
    p2.start()

    c1.daemon = True   # 设置为守护进程 主进程中的代码执行完毕之后,子进程自动结束
    c2.daemon = True

    c1.start()
    c2.start()
    p1.join()
    p2.join()      # 感知一个进程的结束