守护进程(p.daemon = True)将p设置为守护进程
注意:进程之间是互相独立的,主进程代码运行结束,守护进程随即终止(主进程和子进程是异步的),当主进程停止,该守护进程不在继续执行.守护进程也是一种子进程.
主进程创建守护进程
其一:守护进程会在主进程代码执行结束后就终止.(但本质上是在主进程结束之前结束的,主进程需要负责回收资源)
其二:守护进程内无法再开启子进程,否则抛出异常:AssertionError: daemonic processes are not allowed to have children
from multiprocessing import Process
import time
import os
def func(num):
print(f'{num},pid:{os.getpid()},ppid:{os.getppid()}')
while True:
print('is alive')
time.sleep(0.5)
def wahaha():
i = 0
while i lt; 5:
i += 1
print(f'第{i}秒')
time.sleep(1)
if __name__ == '__main__':
Process(target=wahaha).start() #子进程在主进程结束后仍然正常执行
p = Process(target=func,args=(1,))
p.daemon = True #主进程结束,该守护进程结束,将p设置为守护进程
p.start()
time.sleep(3)
print(f'pid:{os.getpid()},ppid:{os.getppid()}')
print('主进程结束')
执行结果:
第1秒
1,pid:8200,ppid:2000
is alive
is alive
第2秒
is alive
is alive
第3秒
is alive
is alive
pid:2000,ppid:7244
主进程结束
第4秒
第5秒
创建守护进程
多进程中的方法
p = Process(target=func,args=(1,)) #创建一个进程对象
p.start() 启动一个进程
p.daemon = True 设置进程为守护进程,随主进程结束而结束.
p.is_alive() 判断进程是否存活,返回bool值
p.terminate() 发送给操作系统指令,关闭进程
p.pid()查看进程pid
另一种执行/编写方式
from multiprocessing import Process
import time
import os
def func(num):
print(f'{num},pid:{os.getpid()},ppid:{os.getppid()}')
while True:
print('is alive')
time.sleep(0.5)
def wahaha():
i = 0
while i < 10:
i += 1
print(f'第{i}秒')#f表示print的格式化输出,待查询
time.sleep(1)
if __name__ == '__main__':
p2 = Process(target=wahaha)
p2.start()
p = Process(target=func,args=(1,))
p.daemon = True #主进程结束,该子进程结束
p.start()
time.sleep(3)
print(p.is_alive())
print(p2.is_alive())
p2.terminate()
time.sleep(0.1)
print(p.is_alive())
print(p2.is_alive())
print(f'pid:{os.getpid()},ppid:{os.getppid()}')
print('主进程结束')
p2.join()
Process方法//看不懂下面
import socket
from multiprocessing import Process
def talk(conn,addr):
while True:
msg_r = conn.recv(1024).decode('utf-8')
print(addr,msg_r)
msg_s = 'client{}登陆'.format(addr)
conn.send(msg_s.encode('utf-8'))
conn.close()
if __name__ == '__main__':
sk = socket.socket()
sk.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
sk.bind(('127.0.0.1',8091))
sk.listen(5)
try:
while True:
conn,addr = sk.accept()
Process(target=talk,args=(conn,addr)).start()
finally:
sk.close()
socket多进程server
import socket
sk = socket.socket()
sk.connect(('127.0.0.1',8091))
while True:
msg_s = input('请输入内容:')
sk.send(msg_s.encode('utf-8'))
msg_r = sk.recv(1024).decode('utf-8')
print(msg_r)
sk.close()
socket多进程client
进程同步(multiprocessing.Lock、Semaphore、Event)
锁 multiprocessing.Lock()
避免同一段代码被多个进程同时执行
lock = Lock() 创建锁对象
lock.acquire() 查询钥匙,如果有就拿走,如果没有就等待
lock.release() 归还钥匙
lock可以使用with上下文进行管理(类似于文件读取)//未理解
with lock:
print('hello' )
维护数据的安全
降低了程序的效率
所有的效率都是建立在数据安全的角度上的
但凡涉及到并发编程都要考虑数据的安全性
我们需要在并发部分对数据修改的操作格外小心,如果会涉及到数据的不安全,就需要进行加锁控制
lock 内部实现了进程之间的通信,使得谁acquire了谁release了能够在多个拥有lock参数的子进程中透明(类似于PV操作)
from multiprocessing import Lock
lock = Lock() #创建一个锁对象
lock.acquire() #想拿钥匙,如果有就拿,没有就一直等
print('拿到要钥匙了1')
lock.release() #还钥匙
lock.acquire() #想拿钥匙
print('拿到要钥匙了2')
lock.release() #还钥匙
开启一个进程锁
#db文件内容 {"count": 0}
import json
import time
from multiprocessing import Process,Lock
def search(i):
f =open('db')
ticket_dic =json.load(f)
f.close()
print(f"{i} 正在查票,剩余票数{ticket_dic['count']}")
def buy(i):
with open('db') as f: ticket_dic = json.load(f)
time.sleep(0.2)
if ticket_dic['count'] > 0:
ticket_dic['count'] -= 1
print(f'{i} 买到票了')
time.sleep(0.2)
with open('db','w') as f :json.dump(ticket_dic,f)
else:
print(f"{i} 太火爆被抢购一空了,剩余票数{ticket_dic['count']}")
# def get_ticket(i,lock):
# search(i)
# lock.acquire()
# buy(i)
# lock.release()
def get_ticket(i,lock):
search(i)
with lock:
buy(i)
if __name__ == '__main__':
lock = Lock()
for i in range(10):
p = Process(target=get_ticket,args=(i,lock))
p.start()
火车票查询购买
信号量(标志TrueFalse) multiprocessing.Semaphore() (锁+计数器)
有多个钥匙的锁
互斥锁同时只允许一个线程更改数据,而信号量Semaphore是同时允许一定数量的线程更改数据 。
假设商场里有4个迷你唱吧,所以同时可以进去4个人,如果来了第五个人就要在外面等待,等到有人出来才能再进去玩。
实现:
信号量同步基于内部计数器,每调用一次acquire(),计数器减1;每调用一次release(),计数器加1.当计数器为0时,acquire()调用被阻塞。信号量概念P()和V()的Python实现。信号量同步机制适用于访问像服务器这样的有限资源。
信号量与进程池的概念很像,但是要区分开,信号量涉及到加锁的概念
信号量
sem = Semaphore(4) 创建锁对象,4把钥匙,可以被连续acquire4次
sem.acquire() 查询钥匙,如果有就拿走,如果没有就等待
sem.release() 归还钥匙
sem 可以使用with上下文进行管理(类似于文件读取)
with sem:#待测试
print('hello' )
"""
可能相当于在代码块前后分别加了acquire和release
"""
from multiprocessing import Semaphore
sem = Semaphore(4) #4把钥匙
sem.acquire()#1
print(1)
sem.acquire()#2
print(2)
sem.release()#1
sem.acquire()#2
print(3)
sem.acquire()#3
print(4)
sem.acquire()#4
print(5)
sem.acquire()#5
print(6)
from multiprocessing import Semaphore,Process
import time
import random
# def ktv(sem,i):#方法一
# sem.acquire()
# print(f'{i}走进ktv')
# time.sleep(random.randint(1,3))
# print(f'{i}走出ktv')
# sem.release()
def ktv(sem,i):#方法二
with sem:
print(f'{i}走进ktv')
time.sleep(random.randint(1,3))
print(f'{i}走出ktv')
if __name__ == '__main__':
sem = Semaphore(4)
for i in range(10):
p = Process(target=ktv,args=(sem,i))
p.start()
事件 multiprocessing.Event()
控制子进程执行还是阻塞的一个机制
e = Event() 创建一个事件对象
Event方法在事件中有一个信号(标志)
wait() 如果这个标志是True,那么wait的执行效果就是pass ,如果是False,那么wait方法的效果就是阻塞,直到这个标志变成True。
控制标志方法
is_set() 判断标志的状态,返回bool值
set() 将标志设置为True
clear() 将标志设置为False
from multiprocessing import Event
e = Event() #阻塞,事件的创建之初标志的状态是False
print(e.is_set())
e.set() #将标志改为True
print(e.is_set())
e.wait() #当标志为True是pass,不阻塞
创建一个事件
from multiprocessing import Event,Process
import time
def func1(e):
print('start func1')
print(e.is_set()) #事件创建之初是False
e.wait(1) #不修改状态(网络测试,发送短信,发送邮件),超时后继续执行,不继续阻塞
print(e.is_set())
e.wait() #持续阻塞
print(e.is_set()) #主进程3(异步)s后修改信号标志为True ,继续执行
print('end func1')
if __name__ == '__main__':
e = Event()
Process(target=func1,args=(e,)).start()
time.sleep(3)
e.set()
事件的控制
from multiprocessing import Event,Process
import time
import random
def tarffic_light(e):
while True:
while e.is_set():
print('绿灯亮')
time.sleep(2)
e.clear()
else:
print('红灯亮')
time.sleep(2)
e.set()
def car(i,e):
while not e.is_set():
print(f'{i}正在等待通过...')
e.wait()
else:
print(f'{i}通过.')
if __name__ == '__main__':
e = Event()
light = Process(target=tarffic_light,args=(e,))
light.daemon =True
light.start()
car_list = []
for i in range(1,21):
p = Process(target=car,args=(i,e))
car_list.append(p)
p.start()
time.sleep(random.randint(0,3))
for i2 in car_list:i2.join() #控制子进程先执行完毕
print('执行完啦')
while版红绿灯
import time
import random
from multiprocessing import Process,Event
def traffic_light(e):
print('红灯亮')
while True:
time.sleep(2)
if e.is_set():
print('红灯亮')
e.clear()
else:
print('绿灯亮')
e.set()
def car(i,e):
if not e.is_set():
print('car%s正在等在通过'%i)
e.wait()
print('car%s通过'%i)
if __name__ == '__main__':
e = Event()
light = Process(target=traffic_light,args=(e,))
light.daemon = True
light.start()
car_lst = []
for i in range(20):
p = Process(target=car,args=(i,e))
p.start()
time.sleep(random.randint(0,3))
car_lst.append(p)
for car in car_lst:car.join()
if 红绿灯
说明:红绿灯的的变化和汽车的通行是两个独立的进程,汽车通过对红绿灯的事件信号的查询判断等待和放行,每一个汽车都是独立的进程
进程间通信(进程之间数据共享)
队列multiprocessing.Queue (先进先出)队列是基于(管道+锁)实现的
创建共享的进程队列,Queue是多进程安全的队列,可以使用Queue实现多进程之间的数据传递。
Queue([maxsize])
创建共享的进程队列。
参数 :maxsize是队列中允许的最大项数。如果省略此参数,则无大小限制。
底层队列使用管道和锁定实现。
q =Queue() 创建一个队列 q = Queue(5) 队列长度为5
q.put(1) 向队列中放一个数据,可以是int,list,dict …当队列满时会阻塞
q.get() 从队列中获取一个数据 没有值会一直阻塞
q.empty() 判断队列是否为空返回bool值 多进程时不准 ,如果其他进程或线程正在往队列中添加项目,结果是不可靠的。也就是说,在返回和使用结果之间,队列中可能已经加入新的项目。注重进程访问控制
q.full() 判断队列是否已满返回bool值 多进程时不准由于线程的存在,结果也可能是不可靠的。注重进程访问控制
q.qsize()返回队列中目前项目的正确数量。此函数的结果并不可靠,因为在返回结果和在稍后程序中使用结果之间,队列中可能添加或删除了项目。在某些系统上,此方法可能引发NotImplementedError异常。注重进程访问控制
q.close()关闭队列,防止队列中加入更多数据。调用此方法时,后台线程将继续写入那些已入队列但尚未写入的数据,但将在此方法完成时马上关闭。如果q被垃圾收集,将自动调用此方法。关闭队列不会在队列使用者中生成任何类型的数据结束信号或异常。例如,如果某个使用者正被阻塞在get()操作上,关闭生产者中的队列不会导致get()方法返回错误。
q.cancel_join_thread()不会再进程退出时自动连接后台线程。这可以防止join_thread()方法阻塞。
q.join_thread()连接队列的后台线程。此方法用于在调用q.close()方法后,等待所有队列项被消耗。默认情况下,此方法由不是q的原始创建者的所有进程调用。调用q.cancel_join_thread()方法可以禁止这种行为。
q = Queue(3)
try:
q.get_nowait()#就算被锁了,也往外拿出,除非empty
except:
print('队列中没有值')
q.get_nowait()
q = Queue(3)
q.put(1)
q.put('aaa')
q.put([1,2,3])
# q.put('alex') #队列满会阻塞,就会一直卡在那里,对单进程丝毫没有体现作用,需要多进程,另一个进程get一个数据,此命令才可能执行
try:
q.put_nowait('alex')#就算被锁了,也往里加入,除非full
except:
print('丢失了一个数据')
q.put_nowait()
创建一个队列
from multiprocessing import Process,Queue
def func(num,q):
q.put({num:num**num})
if __name__ == '__main__':
q = Queue()
# p = Process(target=func, args=(10,q))
# p.start()
# print(q.get())
for i in range(10):
p = Process(target=func,args=(i,q))
p.start()
for i in range(10):
print(q.get())
=============
{0: 1}
{1: 1}
{3: 27}
{4: 256}
{2: 4}
{5: 3125}
{9: 387420489}
{8: 16777216}
{6: 46656}
{7: 823543}
使用Queue队列特性使用put,get解决返回值问题