进程数据隔离.守护进程,进程同步工具
一.进程之间的数据隔离:
from multiprocessing import Process n=100 #主程序中变量n= def func():global n #子进程中引用父进程中变量n,n=n-1return 111 if __name__=="__main__": # "子进程必须写在它下面"n_l=[] # 创建一个新列表for i in range(100): #计数p=Process(target=func) #创建一个子进程,子进程对象是funcp.start() #向操作系统申请开启一个子进程 自动执行run 方法n_l.append(p) # 将每一个子进程添加到列表中print(n_l) #列表里是类似于<Process(Process-1, stopped)>的元素for p in n_l: #循环遍历 每一个元素p.join() #所有子进程都结束在执行下面的程序print(n) #100 #结果=100 显然子进程并没有引用到父进程的变量.
进程之间的数据隔离:
总结:
1.进程与进程之间数据是隔离的,
2.内存空间是不能共享的
3.所以想要进行通信,必须借助其他手段,且这两个进程都是自愿的.
4.子进程的执行结果父进程获取不到
5.父进程如何获取子进程的执行结果:通过socket通信.
二.守护进程:
import time
from multiprocessing import Process
例一.
def func():
print("begin")
time.sleep(3)
print("wahaha")
if __name__=="__main__":
p=Process(target=func)
p.daemon=True
注意:
# 属性:守护进程的属性,默认是False,如果设置成True,就表示设置这个子进程为一个守护进程
# 守护进程的位置:设置守护进程的操作应该在开启子进程之前
p.start()
time.sleep(1)
print("主进程") #结果 只打印begin 主进程,
#例二:
def func1():print("begin") #2打印begintime.sleep(3) #3 休三秒print("wahaha") #12.打印 wahaha
def func2():while True:print("in func2") #7.打印 in func2 9.打印infunc2time.sleep(0.5) #8.睡0.5秒
if __name__=="__main__":Process(target=func1).start() #1 创建一个子进程,子进程对象为func1,并向操作系统申请开启p=Process(target=func2) #4 再创建一个子进程,子进程对象为func2,p.daemon=True #5.设置守护进程操作p.start() # 6.申请开启子进程func2time.sleep(1) #10睡 1秒print("主进程") #11.打印主进程
总结:
守护进程会在主进程的代码执行完毕之后直接结束,无论守护进程是否执行完毕
应用:
报活 主进程还活着
为什么要用守护进程来报活,不用主进程来工作?
守护进程报活几乎不占用CPU,也不需要操作系统去调度
主进程不能严格的每60秒就发送一条信息.
三.进程同步的工具
相关知识:
进程 : 同一时刻可以做多件事情 互相之间不影响
进程之间是异步;
进程同步的工具:锁( Lock ),信号量( Semaphore ) ,事件( Event )
同步:有先后顺序
(一). 锁Lockfrom multiprocessing import Locklock=Lock() #创建一把锁#两个方法lock.acquire() #获取这把锁的钥匙lock.release() #归还这把锁的钥匙 #抢票的例子(每个人都能查看余票,买票import json #导入json模块 import time #导入时间模块 from multiprocessing import Process #导入Process模块 from multiprocessing import Lock #导入Lock模块 def search(i):#定义一个查票函数with open("db","r")as f: # 2 打开文件,读取文件数据count_dic=json.load(f) # 3 将读取数据反序列化得到数据本身time.sleep(0.2) # 4网络延迟 从数据库中读取内容需要消耗一定的时间.print("person%s 余票:%s张"%(i,count_dic["count"])) # 5.显示用户信息和查询数据 def buy(i): #定义一个购票函数with open("db","r",encoding="utf-8")as f: # 8.打开文件,读取数据count_dic=json.load(f) # 9.反序列化得到原数据if count_dic["count"]>0: # 10.判断剩余票数是否>0count_dic["count"]=count_dic["count"]-1 # 11.大于零则将原票数减1print("person%s购票成功"% i) # 12显示用户购票成功time.sleep(0.2) # 13网络延迟 (给数据库传递新票务信息需要时间)with open("db","w",encoding="utf-8")as f: # 14打开文件json.dump(count_dic,f) # 15 将更改后的数据写进数据库def task(i,lock): #定义一个任务函数search(i) # 1 执行函数search ,将序号i传给函数searchlock.acquire() # 6.用lock的acquire方法获取这把锁钥匙 (buy函数被创建的锁锁住)buy(i) # 7.执行函数buy() 并将参数i传给函数lock.release() # 16 用户归还钥匙 if __name__=="__main__": #必须在这一步下面创建子进程lock=Lock() #创建一个锁lockfor i in range(10): #计数10以下p=Process(target=task,args=(i,lock)) #创建一个子进程,子进程对象是task,有两个参数(一个是序号i,一个是加锁) 需要创建十个子进程p.start() #申请开启一个子进程 应用:
当多个进程共享一段数据的时候,数据会出现不安全的现象,需要加锁来维护数据的安全性 注意: from multiprocessing import Lock lock=Lock() lock.acquire() print(111) lock.release() lock.acquire() # 阻塞状态 (只有一把钥匙已经被获取,且尚未归还) print(222) #不加只打印111 #解决办法: 只需要在第二次获取钥匙前将钥匙归还即加上 lock.release() 加上lock.release()就可以打印111,222
(二).信号量(Semaphore)
信号量的本质: 多把钥匙对应一把锁
lock+count计数
现象:
from multiprocessing import Process from multiprocessing import Semaphore sem=Semaphore(3) sem.acquire() print(1) sem.acquire() print(2) sem.acquire() print(3) #sem.release() sem.acquire() #阻塞状态 如果加sem.release() print(4) #不打印
案例:商场唱吧(KTV)
场景:四个小房子,十个人排队等待进入房间
import time #导入时间模块import random #导入random模块from multiprocessing import Process #导入Process模块from multiprocessing import Semaphore #导入Semaphore信号量 模块def ktv(num,sem):#定义一个函数ktvsem.acquire() # 1 获取一把钥匙 6 下一个用户(进程)获取钥匙print("person%s进入ktv"% num) # 2 显示用户信息及正在使用状态time.sleep(random.randint(1,4)) # 3 使用时间段print("person%s离开ktv"% num) # 4 显示用户离开sem.release() # 5 归还钥匙if __name__=="__main__": #必须在这一条件下面创建新进程sem=Semaphore(4) #可允许四人同时使用for i in range(10): #计数 一共需要创建十个子进程p=Process(target=ktv,args=(i,sem)) # 创建一个子进程p 子进程对象为ktv.需要两个参数(序号,sem)p.start() # 申请开启一个子进程 归还钥匙后,
(三).事件(Event)
方法:
等待: wait() 如果这个标志是False 那么就阻塞
如果这个标志是True 那么就非阻塞
查看标志: is_set()
修改标志:set()将标志设置为True
clear()将标志设置为False
现象: from multiprocessing import Event e = Event() print(e.is_set()) #False 在事件创建之初默认是False e.set() #将标志设置为True print(e.is_set()) #True e.wait() #相当于什么也没做 e.clear() #将标志设置为False e.wait(timeout=10) #阻塞10秒如果信号在阻塞10s之内变为True,那么不继续阻塞直接pass, # # 如果就阻塞10s之后状态还是没变,那么继续, # e.wait()可以加参数 # 无论前面的wait的timeout是否通过,我的状态都不会因此改变 print(e.is_set()) #False
红绿灯模型: 控制交通灯的进程;import timeimport randomfrom multiprocessing import Eventfrom multiprocessing import Processdef trafic_light(e):print("\033[1;31m红灯亮\033[0m") # 1 打印红灯亮while True: #2无限循环time.sleep(2) #3睡两秒# print(1,e.is_set()) #fif e.is_set(): # 4.条件e.is_set()=False:阻塞print("\033[1;31m红灯亮\033[0m") #5.打印红灯亮e.clear() #6.修改is_set()的状态为False# time.sleep(3)# print(2,e.is_set()) #felse: #7.e.si_set==True如果目前状态是True非阻塞print("\033[1;32m绿灯亮\033[0m") #8.打印绿灯亮# print(4, e.is_set()) #fe.set() #9.设置is_set的状态为True 非阻塞(通行)# print(5,e.is_set()) #Tdef car(i,e):#车函数 (两种情况:等待,通行)# time.sleep(3)# print(3,e.is_set()) #Trueif not e.is_set():# 10.如果e.is_set()的状态是True 则not e.is_set()为False,现在状态是阻塞,print("car%sd等待"% i) #11. #先提示用户进入等待状态e.wait() #12. #直接passprint("car%s通行"% i) #13.和条件判断并行即条件不满足执行这一步if __name__=="__main__":e=Event() #创建一个事件p=Process(target=trafic_light,args=(e,)) #创建一个进程对象为trafic_light ,参数为ep.start() #申请开启进程for i in range(10):p=Process(target=car,args=(i,e)) #创建十个car进程,参数为i,ep.start() #申请开启进程time.sleep(random.randrange(0, 3, 2)) #要么睡两秒,要么不睡.
多进程解决tcp协议一个服务器与多个客户端通信矛盾
服务器端代码:
import socket from multiprocessing import Process #导入类Process def talk(conn): # 0 定义一个函数talk 6.执行talk进程try:while True:conn.send(b'alex') #7.发送信息print(conn.recv(1024)) #8.接收信息finally:conn.close()if __name__=="__main__":sk=socket.socket() # 1 创建一个socket对象sk.bind(("127.0.0.1",9901)) # 2 绑定一个IP地址接口sk.listen() #3 监听try:while True:conn,addr=sk.accept() #4 无限循环可支持多个客户端连接Process(target=talk,args=(conn,)).start() #5 连接以后需要开启一个正常收发信息进程.进程对象就是talk#并向操作系统提出执行talk进程的申请.finally:sk.close()
客户端代码:
import socket import os sk=socket.socket() sk.connect(("127.0.0.1",9901)) while True:print(sk.recv(1024))sk.send(str(os.getpid()).encode('utf-8'))sk.close()
