进程的同步控制——锁 信号量 事件

锁 —— multiprocess.Lock

　　加锁可以保证多个进程修改同一块数据时，同一时间只能有一个任务可以进行修改，即串行的修改，没

错，速度是慢了，但牺牲了速度却保证了数据安全。

#多进程同时抢购余票
import json
import time
import random
from multiprocessing import Lock
from multiprocessing import Process

def search(i):
    with open('ticket') as f:
        print(i,json.load(f)['count'])

def get(i):
    with open('ticket') as f:
        ticket_num = json.load(f)['count']
    time.sleep(random.random())
    if ticket_num > 0:
        with open('ticket','w') as f:
            json.dump({'count':ticket_num-1},f)
        print('%s买到票了'%i)
    else:
        print('%s没票了'%i)

def task(i,lock):
    search(i)   # 查看票
    lock.acquire()
    get(i)      # 抢票
    lock.release()

if __name__ == '__main__':
    lock = Lock()
    for i in range(20):  # 20个人同时抢票
        p = Process(target=task,args=(i,lock))
        p.start()

　　

信号量 —— multiprocess.Semaphore

　　

   互斥锁同时只允许一个线程更改数据，而信号量Semaphore是同时允许一定数量的线程更改数据 。
假设商场里有4个迷你唱吧，所以同时可以进去4个人，如果来了第五个人就要在外面等待，等到有人出来才能再进去玩。
实现：
   信号量同步基于内部计数器，每调用一次acquire()，计数器减1；每调用一次release()，计数器加1.当计数器为0时，acquire()
调用被阻塞。这是迪科斯彻（Dijkstra）信号量概念P()和V()的Python实现。信号量同步机制适用于访问像服务器这样的有限资源。
   信号量与进程池的概念很像，但是要区分开，信号量涉及到加锁的概念

import time
import random
from multiprocessing import Semaphore
from multiprocessing import Process
def sing(i,sem):
    sem.acquire()
    print('%s : 进入 ktv'%i)
    time.sleep(random.randint(1,10))
    print('%s : 出 ktv'%i)
    sem.release()
# 迷你唱吧  20个人，同一时间只能有4个人进去唱歌
if __name__ == '__main__':
    sem = Semaphore(4)
    for i in range(20):
        Process(target=sing,args=(i,sem)).start()

　　

事件 —— multiprocess.Event

　　

python线程的事件用于主线程控制其他线程的执行，事件主要提供了三个方法 set、wait、clear。

    事件处理的机制：全局定义了一个“Flag”，如果“Flag”值为 False，那么当程序执行 event.wait 方法时就会阻塞，
如果“Flag”值为True，那么event.wait 方法时便不再阻塞。

clear：将“Flag”设置为False
set：将“Flag”设置为True

from multiprocessing import Process, Event
import time, random


def car(e, n):
    while True:
        if not e.is_set():  # 进程刚开启，is_set()的值是Flase，模拟信号灯为红色
            print('\033[31m红灯亮\033[0m，car%s等着' % n)
            e.wait()    # 阻塞，等待is_set()的值变成True，模拟信号灯为绿色
            print('\033[32m车%s 看见绿灯亮了\033[0m' % n)
            time.sleep(random.randint(3, 6))
            if not e.is_set():   #如果is_set()的值是Flase，也就是红灯，仍然回到while语句开始
                continue
            print('车开远了,car', n)
            break


def police_car(e, n):
    while True:
        if not e.is_set():# 进程刚开启，is_set()的值是Flase，模拟信号灯为红色
            print('\033[31m红灯亮\033[0m，car%s等着' % n)
            e.wait(0.1) # 阻塞，等待设置等待时间，等待0.1s之后没有等到绿灯就闯红灯走了
            if not e.is_set():
                print('\033[33m红灯,警车先走\033[0m，car %s' % n)
            else:
                print('\033[33;46m绿灯，警车走\033[0m，car %s' % n)
        break



def traffic_lights(e, inverval):
    while True:
        time.sleep(inverval)
        if e.is_set():
            print('######', e.is_set())
            e.clear()  # ---->将is_set()的值设置为False
        else:
            e.set()    # ---->将is_set()的值设置为True
            print('***********',e.is_set())


if __name__ == '__main__':
    e = Event()
    for i in range(10):
        p=Process(target=car,args=(e,i,))  # 创建是个进程控制10辆车
        p.start()

    for i in range(5):
        p = Process(target=police_car, args=(e, i,))  # 创建5个进程控制5辆警车
        p.start()
    t = Process(target=traffic_lights, args=(e, 10))  # 创建一个进程控制红绿灯
    t.start()

    print('============》')