锁机制(Lock) 信号量机制(Semaphore) 事件机制(Event)

IPC  进程间通信(inter-Process Communicate)

锁机制(Lock)

　　l = Lock() 开启一个锁机制(实例化)   一把锁配一个钥匙

　　l.acquire()  获得钥匙，锁门

　　l.release()  还钥匙，开门

# 模拟银行取钱机制
from multiprocessing import Lock,Process
import time

def save_money(l,num):
    l.acquire() # 获得钥匙，锁门
    for i in range(,):
        num +=
        print(num)
    l.release() # 还钥匙，开门

def draw_money(l,num):
    l.acquire()
    for i in range(,):
        num -=
        print(num)
    l.release()

if __name__ == '__main__':
    l = Lock()  # 实例化一个锁
    num =
    p = Process(target=save_money,args=(l,)) # 实例化一个子进程
    p.start()                                                     # 开启子进程
    p1 = Process(target=draw_money,args=(l,)) # 实例化一个子进程
    p1.start()                                                   # 开启p1这个子进程
    time.sleep()
    print(num)

# 模拟抢票机制
from multiprocessing import Process,Lock

def check_ticket(i): # 不受限制所有人都可以查询
    with open('ticket') as f:
        num = f.read()
    print('第%s个人查到还有%s张票。' % (i,num))

def buy_ticket(i,l): # 受限制的，有一个人在买票的时候其他人不能进行买票操作需要等待上一个人操作完。
    l.acquire()
    with open('ticket') as f:
        num = int(f.read())
        if num > 0: # 判断票数是否大于零，否的话则不能进行买不到票。
            print('\033[32m 第%s个人买到票了。\033[0m' % i)
            num -= 1
        else:
            print('\033[31m 第%s个人没有买到票。\033[0m' % i)
    with open('ticket','w') as f: # 把修改后的票数更新到数据库中(此处为文件中)
        f.write(str(num))
    l.release()

if __name__ == '__main__':
    l = Lock()
    for i in range(1,11):
        p = Process(target=check_ticket,args=(i,))
        p.start()
    for i in range(1,11):
        p1 = Process(target=buy_ticket,args=(i,l))
        p1.start()

信号量机制(Semaphore)

　　sem = Semaphore(5) 实例化一个把锁但是这把锁可以有多把钥匙(此处为5把)

　　sem.acquire()  获得钥匙，锁门

　　sem.release()  还钥匙，开门

　　它比Lock多了一个计数器的功能，程序进行一次acquire钥匙个数就减一，进行release一次钥匙个数就加一，当钥匙数为0时，acquire是处于阻塞状态

　　

# 信号量机制的例子
from multiprocessing import Process,Semaphore
import time
import random

def func(i,sem):
    sem.acquire()     # 获得钥匙，锁门
    print('\033[32m 第%s个人进了小黑屋，锁门。\033[0m' % i)
    num = random.randint(1, 3)
    time.sleep(num)
    print(num)
    print('\033[31m 第%s个人出了小黑屋，开门。\033[0m' % i)
    sem.release()     # 还钥匙，开门

if __name__ == '__main__':
    sem = Semaphore(3)    # 实例化一个信号量机制
    for i in range(1,21):
         p = Process(target=func,args=(i,sem)) # 实例化子进程
         p.start()

事件机制(Event)

　　e = Event()  实例化一个事件机制

　　e.set()    将事件机制的is_set()设置为True

　　e.clear()  将事件机制的is_set()设置为False

　　e.wait()    事件通过is_set()的bool值来判断它是否阻塞，当bool值为True时，wait() 为非阻塞状态，bool值为False时，wait() 为阻塞状态。

　　e.is_set()  标识，值是bool类型。

　　

# 事件机制的例子
from multiprocessing import Process,Event
import time

def Tra(e):
    e.set() # 把is_set()的bool值，设置为True
    print('\033[32m 绿灯亮了 \033[0m')
    while 1:
        if e.is_set(): # 判断is_set()的bool值为True，则wait()非阻塞
            time.sleep(5)
            print('\033[31m 红灯亮了 \033[0m')
            e.clear() # 绿灯时间完，把is_set()的bool值设置成False
        else:
            time.sleep(5)
            print('\033[32m 绿灯亮了 \033[0m')
            e.set()  # 红灯时间完，需要变成绿灯，所以需要通过set()来把is_set()的bool值设为True

def Car(e,i):
     e.wait() # 如果is_set()的bool值为True，wait()为非阻塞，可以通车，否则就为阻塞不可以通车
     print('第%s辆车通过' % i)

if __name__ == '__main__':
    e = Event() # 实例化一个事件机制
    traffic_light = Process(target=Tra,args=(e,))
    traffic_light.start()
    for i in range(1,51):
        time.sleep(1)
        car = Process(target=Car,args=(e,i))
        car.start()