并发编程 之 进程 之 进程的模型: 进程同步的工具 (三) 继 创建进程( 守护进程)

multiProcessing 包中 Process模块:

　　join() 堵塞问题, 可以理解为:  相当于 每个子进程结束时都会给 父进程发一条消息, join() 则是接收,内部有socket的实现

　　1, 进程之间的数据隔离问题
　　　　进程和进程之间的数据是隔离的, 内存空间不能共享,所以要想进行通信, 必须借助其他方法. 且这两个进程都是自愿的.
　　　　父子进程之间通过socket 通信.
　　2, 守护进程:
　　　　daemon = True 守护进程的属性, 默认是 False 如果 设置成True 就表示设置这个子进程为一个守护进程. 且 设置守护进程的操作应该字开启子进程之前.
　　　　守护进程会在主进程的代码执行完毕之后直接结束, 无论守护进程是否执行完毕.  *******

 1 def func1():
 2     print('begin')
 3     time.sleep(3)
 4     print('wahaha')
 5 
 6 if __name__ == '__main__':
 7     p = Process(target=func1)
 8     p.daemon = True
 9     # 守护进程的属性,默认是False,如果设置成True,就表示设置这个子进程为一个守护进程
10     # 设置守护进程的操作应该在开启子进程之前
11     p.start()
12 
13     time.sleep(1)
14     print('主进程')
15 
16 '''
17 输出结果:
18 bigin
19 主进程
20 '''

守护进程的例子(一)

　　　　主要应用于: 报活: 报 主进程还活着.

 1 def func1():
 2     print('begin')
 3     time.sleep(3)
 4     print('wahaha')
 5 
 6 def func2():
 7     while True:
 8         print('in func2')
 9         time.sleep(0.5)
10 
11 if __name__ == '__main__':
12     Process(target=func1).start()
13     p = Process(target=func2)
14     p.daemon = True
15     p.start()
16     time.sleep(1)
17     print('主进程')
18 '''
19 输出结果:
20 begin
21 in func2
22 in func2
23 主进程
24 wahaha         # 在等待打印 'wahaha'的时候 不会再次执行 守护进程的内容
25 '''

守护进程的例子(二)

小结: 进程: 同一时刻可以做多件事情, 互相之间不影响.

进程的模型: 进程同步的工具. 　　 ps: 有先后顺序 就是同步, 进程之间都是异步的,

　　1. 锁 Lock模块: 保证一段代码,在同一时刻只能被一个进程执行.
　　　　lock = Lock() 　  创造了一把锁
　　　　acquire() 　　    获取锁的钥匙
　　　　release() 　　　归还这把锁的钥匙
　　ps: 多进程的数据的不安全性: 当多个进程共享一段数据的时候, 数据会出现不安全的现象, 需要加锁, 来维护数据的安全性.

 1 # 代码中涉及到一个 dp文件, 此文件用来单纯的模拟 其他机器上公用的数据库
 2 
 3 '''
 4 抢票分析: 
 5 1, 客户可以同一时间访问服务器,并且访问到 同一个余票数
 6 2, 当客户发出购买请求, 服务器必须进行同步处理, 一个一个来. 
 7 问: 如何在 并行异步的程序里,实现同步处理某一个功能
 8 '''
 9 
10 
11 import json
12 import time
13 from multiprocessing import Lock
14 from multiprocessing import Process
15 def search(i):
16     with open('db','r') as f:count_dic = json.load(f)
17     time.sleep(0.2)
18     print('person %s 余票 : %s张'%(i,count_dic['count']))
19 
20 def buy(i):
21     with open('db','r') as f:count_dic = json.load(f)
22     time.sleep(0.2)
23     if count_dic['count'] > 0:
24         count_dic['count'] -= 1
25         print('person %s 购票成功'%i)
26     time.sleep(0.2)
27     with open('db','w') as f:json.dump(count_dic,f)
28 
29 def task(i,lock):
30     search(i)
31     lock.acquire()   # 如果之前已经被acquire了 且 没有被release 那么进程会在这里阻塞
32     buy(i)
33     lock.release()
34 
35 if __name__ == '__main__':
36     lock = Lock()
37     for i in range(10):
38         p = Process(target=task,args=(i,lock))
39         p.start()

lock 抢票的例子

　　2, 信号量 Semaphore模块: 多把钥匙 对应一把锁

　　　　本质就是: lock+count 计数 来实现的

　　3, 事件 Event模块: 

　　　　标志:在 事件创立之初,标志默认为False

　　　　wait(timeout=None) 等待 有一个关键字参数 timeout(超时) 以秒为单位.
　　　　　　1, 阻塞, 如果标志为False 就是 阻塞
　　　　　　2, 非阻塞, 如果标志为True 就是 非阻塞
　　　　is_set() 查看标志
　　　　set() 修改标志的值为True
　　　　clear() 修改标志的值为False

 1 import time
 2 import random
 3 from multiprocessing import Event,Process
 4 
 5 def traffic_light(e):
 6     print('\033[1;31m 红灯亮\033[0m')
 7     while True:
 8         time.sleep(2)
 9         if e.is_set():
10             print('\033[1;31m 红灯亮\033[0m')
11             e.clear()
12         else:
13             print('\033[1;32m 绿灯亮\033[0m')
14             e.set()
15 
16 
17 # 车 等或者通过
18 def car(id,e):
19     if not e.is_set():
20         print('car %s 等待' % id)
21         e.wait()
22     print('car %s 通过'%id)
23 
24 def police_car(id,e):
25     if not e.is_set():
26         e.wait(timeout = 0.5)
27     print('police car %s 通过' % id)
28 
29 # 主进程 启动交通控制灯 启动车的进程
30 if __name__ == '__main__':
31     e = Event()
32     p = Process(target=traffic_light,args=(e,))
33     p.start()
34     car_lst = [car,police_car]
35     for i in range(20):
36         p = Process(target=random.choice(car_lst), args=(i,e))
37         p.start()
38         time.sleep(random.randrange(0,3,2))

红绿灯模型事件