python学习Day36--信号 事件

一、回顾

1、一些名词回顾：

并行：两个进程在同一时间点发生

并发：两个进程在同一时间间隔内运行

同步：某一个任务的执行必须依赖于另一个任务的返回结果

异步：某一个任务的执行，不需要依赖于另一个任务的返回，只需要告诉另一个任务一声

阻塞：程序因为类似IO等待，等待事件导致无法继续执行

非阻塞：程序遇到类似IO操作时，不再阻塞等待，如果没有及时的处理IO，就报错或者跳过等替他操作

2、进程的方法和属性：

（1）方法：

　　start( )　　　　开启一个进程

　　join( ）　　　   异步变同步，让父进程等待子进程的结束，再继续执行

　　is_alive( )　　  判断进程是否活着

　　terminate　　   杀死进程

（2）属性：

　　name　　　　子进程的名称

　　pid　　　　     子进程的pid

　　daemon            设置进程为守护进程，给一个True代表为守护进程，默认为False

3、守护进程：

（1）特点：

　　随着父进程的结束而结束

　　守护进程不能创建子进程

　　守护进程必须要在start之前设置

（2）代码：

from multiprocessing import Process

import time

def func1():
    for i in range(65,90):
        print(chr(i))
        time.sleep(0.5)

def func():
    for i in range(10):
        print(i)
        time.sleep(0.5)

if __name__ == '__main__':
    p = Process(target=func)
    p.start()
    p1 = Process(target=func1)
    p1.daemon = True
    p1.start()
    # time.sleep(2)

    # print(p.is_alive())
    # p.terminate()
    # p.join()
    # print(p.is_alive())
    # print(p.pid,p.name)
    # for i in range(10,21):
    #     print(i)
    #     time.sleep(1)

二、锁机制

1、问题的产生？

　　数据共享使用时可能会出现混乱，比如以下代码实现的数据共享就会出现这样的情况。

# *******************问题**********************开始
from multiprocessing import Process,Value
import time

def get_money(num): # 取钱
    for i in range(100):
        num.value -= 1
        time.sleep(0.01)

def put_money(num): # 存钱
    for i in range(100):
        num.value += 1
        time.sleep(0.01)

if __name__ == '__main__':
    num = Value('i',100) # 数据类型+值(数据共享)
    p = Process(target=get_money,args=(num,))
    p.start()
    p1 = Process(target=put_money,args=(num,))
    p1.start()
    p.join()
    p1.join()
    print(num.value) # 获取到子进程的num
# *******************问题**********************结束

2、解决问题——锁机制

（1）锁涉及两个操作：

　　拿钥匙，锁门：——不让别人进屋

　　换钥匙，开门：——让别人进屋

（2）锁的特点是：一把钥匙配一把锁

（3）锁的相关代码：

from multiprocessing import Lock

l = Lock()

l.acquire()  # 拿走钥匙，锁门，不让其他人进屋

l.release()  # 释放锁，还钥匙，开门，允许其他人进入

（4）用锁解决问题对应的代码

from multiprocessing import Process,Value,Lock
import time

def get_money(num,l): # 取钱
    l.acquire() # 拿走钥匙，锁上门，不让其他人进来
    for i in range(100):
        num.value -= 1
        time.sleep(0.01)
    l.release()  # 还钥匙，开门，允许其他人进入

def put_money(num,l): # 存钱
    l.acquire()  # 拿走钥匙，锁上门，不让其他人进来
    for i in range(100):
        num.value += 1
        time.sleep(0.01)
    l.release()  # 还钥匙，开门，允许其他人进入

if __name__ == '__main__':
    l = Lock()  # 设置一把锁
    num = Value('i',100) # 数据类型+值(数据共享)
    p = Process(target=get_money,args=(num,l))
    p.start()
    p1 = Process(target=put_money,args=(num,l))
    p1.start()
    p.join()
    p1.join()
    print(num.value) # 获取到子进程的num

（5）模拟抢票

# *******************抢票**********************开始
from multiprocessing import Process,Lock
import time


def check(i):
    with open("余票") as f:
        con = f.read()
    print("第%s个人查到余票还剩%s张" % (i,con))

def buy_ticket(i,l):
    # 这里的锁是保护在多进程中数据安全
    l.acquire()
    with open("余票") as f:
        con = int(f.read())
        time.sleep(0.1)

    if con > 0:
        print('33[31m 第%s个人买到了票33[0m' % i)
        con -= 1
    else:
        print("33[32m 第%s个人没有买到票33[0m" % i)
    time.sleep(0.1) # 是指，买完票后，把余票数量重新写入数据库的延迟时间

    with open("余票",'w') as f:
        f.write(str(con))
    l.release()


if __name__ == '__main__':
    l = Lock()
    for i in range(10):
        p_ch = Process(target=check,args=(i+1,))
        p_ch.start()
    for i in range(10):
        p_buy = Process(target=buy_ticket,args=(i+1,l))
        p_buy.start()

# *******************抢票**********************结束

三、信号机制

1、信号量

　　一把锁配多把钥匙。、

　　信号量机制比锁机制多了一个计数器，这个计数器是用来记录当前剩余几把钥匙的。

from multiprocessing import Semaphore

l = Semaphore(3)  # 一把锁配3把钥匙

l.acquire() # 拿走一把钥匙，锁上门
print(123)
l.acquire() # 拿走一把钥匙，锁上门
print(456)
l.acquire() # 拿走一把钥匙，锁上门
print(789)
l.acquire() # 在此会阻塞，等待其他钥匙归还（释放）
print(111)

2、举例操作

# *******************信号机制——案例**********************开始
from multiprocessing import Semaphore,Process
import time
import random

def func(i,sem):
    sem.acquire()
    print('第%s个人进入小黑屋，拿了钥匙上门' % i)
    time.sleep(random.randint(3,5))
    print('第%s个人出去小黑屋，还了钥匙打开门' % i)
    sem.release()

if __name__ == '__main__':
    sem = Semaphore(5) # 初始化一把锁5把钥匙
    for i in range(20):
        p = Process(target=func,args=(i,sem,))
        p.start()
# *******************信号机制——案例**********************结束

四、事件机制

1、事件机制介绍：　

　　事件是通过is_set( )的bool值，去标识e.wait( )的阻塞状态。

　　当is_set( )的bool值为False时，e.wait( )是阻塞状态。

　　当is_set( )的bool值为True时，e.wait( )是非阻塞状态。

　　当使用set( )时，是把is_set的bool值变为True.

　　当使用clear( )时，是把is_set的bool值变为False。

from multiprocessing import Event

e = Event()

print(e.is_set()) # False
e.set() # 将is_set的bool值变为True, 将wait变为非阻塞
e.wait()
print(e.is_set()) # True
print(123)
e.clear()
print(e.is_set()) # False
e.wait()  # 阻塞
print(456)

2、案例：

　　红绿灯事件。

# *******************事件机制——案例**********************开始
from multiprocessing import Process,Event
import time


def tra(e):
    '''信号灯函数'''
    e.set()
    print("33[32m 绿灯亮! 33[0m")  # 红灯亮了5秒后提示绿灯亮
    while 1:
        if e.is_set(): # True，代表绿灯亮,那么此时代表可以过车
            time.sleep(5) # 所以在这让灯等5秒钟，这段时间让车过
            print('33[31m 红灯亮! 33[0m') # 绿灯亮了5秒应该提示红灯亮
            e.clear() # 把is_set设置为False
        else:
            time.sleep(5) # 此时代表红灯亮了，红灯亮5秒
            print("33[32m 绿灯亮! 33[0m") # 红灯亮了5秒后提示绿灯亮
            e.set() # 将is_set设置为True


def Car(i,e):
    e.wait() # 车在等红绿灯，is_set为False时不过，True时过车
    print("第%s辆车过去了" % i)

if __name__ == '__main__':
    e = Event()
    traffic_light = Process(target=tra,args=(e,)) # 信号灯的进程
    traffic_light.start()
    for i in range(50): # 描述50辆车
        if i % 3 == 0:
            time.sleep(2)
        car = Process(target=Car,args=(i+1,e,)) # 汽车的进程
        car.start()
# *******************事件机制——案例**********************结束