一、Process
参数介绍：
1 group参数未使用，值始终为None
2 target表示调用对象，即子进程要执行的任务
3 args表示调用对象的位置参数元组，args=(1,2,'a',)
4 kwargs表示调用对象的字典,kwargs={'name':'a','age':18}
5 name为子进程的名称 方法介绍：
1 p.start()：启动进程，并调用该子进程中的p.run()
2 p.run():进程启动时运行的方法，正是它去调用target指定的函数，我们自定义类的类中一定要实现该方法
3 p.terminate():强制终止进程p，不会进行任何清理操作，如果p创建了子进程，该子进程就成了僵尸进程，使用该方法需要特别小心这种情况。如果p还保存了一个锁那么也将不会被释放，进而导致死锁
4 p.is_alive():如果p仍然运行，返回True
5 p.join([timeout]):主线程等待p终止（强调：是主线程处于等的状态，而p是处于运行的状态）。timeout是可选的超时时间，需要强调的是，p.join只能join住start开启的进程，而不能join住run开启的进程 属性介绍：
1 p.daemon：默认值为False，如果设为True，代表p为后台运行的守护进程，当p的父进程终止时，p也随之终止，并且设定为True后，p不能创建自己的新进程，必须在p.start()之前设置
2 p.name:进程的名称
3 p.pid：进程的pid
4 p.exitcode:进程在运行时为None、如果为–N，表示被信号N结束(了解即可)
5 p.authkey:进程的身份验证键,默认是由os.urandom()随机生成的32字符的字符串。这个键的用途是为涉及网络连接的底层进程间通信提供安全性，这类连接只有在具有相同的身份验证键时才能成功（了解即可） 1、join：父进程等待子进程结束后才开始执行自己的代码
# 发送一封邮件
import time
import random
from multiprocessing import Process def func():
time.sleep(random.randint(1,3)) # 模拟邮件发送的延迟
print('邮件已发送') if __name__ == '__main__':
p = Process(target=func)
p.start()
p.join() # 阻塞 直到进程p执行完毕后才结束阻塞
print('邮件发送完毕') # 发送十封邮件
import time
import random
from multiprocessing import Process def func(index):
time.sleep(random.randint(1,3))
print('第%s封邮件发送完毕' %index) if __name__ == '__main__':
p_lst = []
for i in range(10):
p = Process(target=func,args=(i,))
p.start() # 先让所有子进程都启动
p_lst.append(p)
for p in p_lst: # 再进行join阻塞
p.join()
print('10封邮件全部发送完毕') 2、用类的方式开启进程
我们之前创建进程的时候，其实也是在创建一个Process类的对象，再调用对象的start方法开启进程，
那么我们也可以自己定义一个类来实现进程的创建： import os
from multiprocessing import Process class MyProcess(Process): # 定义一个类，继承Process类
def run(self): # 必须实现的方法，是启动进程的方法
print('子进程:',os.getpid(),os.getppid()) if __name__ == '__main__':
p = MyProcess() # 实例化
p.start() # 自动调用run方法
print('父进程:',os.getpid()) 给自定义类传参：
首先看看Process源码
import time
import os
from multiprocessing import Process class MyProcess(Process):
def __init__(self,i):
super().__init__() # 实现父类的初始化方法
self.index = i # 定义自己的属性(参数) def run(self):
time.sleep(1)
print('子进程:',self.index,os.getpid(),os.getppid()) if __name__ == '__main__':
p_lst = []
for i in range(10):
p = MyProcess(i)
p.start()
p_lst.append(p)
for p in p_lst:
p.join()
print('主进程:',os.getpid())
import os
from multiprocessing import Process def func():
print("i am target func") class MyProcess(Process): # 定义一个类，继承Process类
def __init__(self, target):
super(MyProcess, self).__init__() # 实现父类的初始化方法
self.target = target def run(self): # 必须实现的方法，是启动进程的方法
self.target()
print('子进程:', os.getpid(), os.getppid()) if __name__ == '__main__':
p = MyProcess(target=func) # 实例化
p.start() # 自动调用run方法
print('父进程:', os.getpid()) # 结果
父进程: 3532
i am target func
子进程: 9628 3532
3、守护进程
主进程创建守护进程
1：守护进程会在主进程代码执行结束后就终止
2：守护进程内无法再开启子进程,否则抛出异常：AssertionError: daemonic processes are not allowed to have children
注意：进程之间是互相独立的，主进程代码运行结束，守护进程随即终止 1，守护进程会在主进程代码执行结束后就终止
import time
from multiprocessing import Process def func():
print('子进程 start')
time.sleep(3) # 睡3秒的时候主进程的代码已经执行完毕了，所以子进程也会跟着结束
print('子进程end') if __name__ == '__main__':
p = Process(target=func)
p.daemon = True # daemon是Process的属性
p.start()
time.sleep(2) # 睡2秒的时候，执行了子进程
print('主进程')
结果：
子进程 start
主进程 2，守护进程会在主进程代码执行结束后就终止 ，但是父进程会等待子进程结束才正式结束。
注意：代码结束是指代码运行到了最后一行，并不代表进程已经结束了。
import time
from multiprocessing import Process
def func():
count = 1
while True:
print('*' * count)
time.sleep(1)
count += 1 def func2():
print('普通进程开始')
time.sleep(5)
print('普通进程结束') if __name__ == '__main__':
p1 = Process(target=func)
p1.daemon = True
p1.start() Process(target=func2).start()
time.sleep(3)
print('主进程') 结果：
*
普通进程开始
**
***
主进程
普通进程结束 3，守护进程的作用
守护进程可以报活，就是向某个服务报告自己还活着 场景：
例如你写好了一个网页，你的服务端是不应该停的，因为你服务端一旦停止了，别人就无法访问你的网页了，所以我们应该确保服务端没有‘死’，
这个时候就可以使用守护进程，在你的服务端起一个守护进程，让这个进程只做一件事，就是每隔1个小时(时间按照自己的合理安排设定)向某一台机器汇报自己还活着，
一旦这个机器没有收到你守护进程传来的消息，那么就可以认为你的服务端已经挂了。 例如：
import time
from multiprocessing import Process
def Guard():
while True:
time.sleep(3600)
print('我还活着') # 向某个机器汇报我还活着，具体该怎么写汇报的逻辑就怎么写，这里只是示范 if __name__ == '__main__':
p = Process(target=Guard)
p.daemon = True
p.start()
# 主进程的逻辑(主进程应该是一直运行的，不应该有代码结束的时候)
print('主进程') 4、terminate：关闭进程
import time
from multiprocessing import Process
def fun():
print('子进程') if __name__ == '__main__':
p = Process(target=fun)
p.start()
p.terminate() # 关闭进程,不会立即关闭,所以is_alive立刻查看的结果可能还是存活
print(p.is_alive()) # True
time.sleep(0.1)
print(p.is_alive()) # False 二、锁 Lock
1、异步的问题
我们都知道异步进程的好处就是可以一起执行，效率高，但是当多个进程使用同一份数据资源的时候，就会引发数据安全或顺序混乱问题。 抢票系统：
#文件ticket的内容为：{"count":3}
#注意一定要用双引号，不然json无法识别
#并发运行，效率高，但竞争写同一文件，数据写入错乱 import time
import json
from multiprocessing import Process
def search(person):
with open('ticket') as f:
ticketinfo = json.load(f)
print('%s查询余票：' %person,ticketinfo['count']) def get_ticket(person):
with open('ticket') as f:
ticketinfo = json.load(f)
time.sleep(0.2) #模拟读数据的网络延迟
if ticketinfo['count'] > 0:
print('%s买到票了'%person)
ticketinfo['count'] -= 1
time.sleep(0.2)
with open('ticket','w') as f:
json.dump(ticketinfo,f)
else:
print('%s没买到票'%person) def ticket(person):
search(person)
get_ticket(person) if __name__ == '__main__':
for i in range(5):
p = Process(target=ticket,args=('person%s'%i,))
p.start()
结果：
person0查询余票： 3
person4查询余票： 3
person1查询余票： 3
person2查询余票： 3
person3查询余票： 3
person0买到票了
person4买到票了
person1买到票了
person2买到票了
person3买到票了 分析：票只有三张，但是5个人都显示买到了，这是因为5个进程异步进行，大家都同一时间在对一个文件进行修改，导致的混乱。2、用锁解决：
# 加锁降低了程序的效率，让原来能够同时执行的代码变成顺序执行了，异步变同步的过程
# 保证了数据的安全 import time
import json
from multiprocessing import Process
from multiprocessing import Lock # 导入Lock类
def search(person):
with open('ticket') as f:
ticketinfo = json.load(f)
print('%s查询余票：' %person,ticketinfo['count']) def get_ticket(person):
with open('ticket') as f:
ticketinfo = json.load(f)
time.sleep(0.2) #模拟读数据的网络延迟
if ticketinfo['count'] > 0:
print('%s买到票了'%person)
ticketinfo['count'] -= 1
time.sleep(0.2)
with open('ticket','w') as f:
json.dump(ticketinfo,f)
else:
print('%s没买到票'%person) def ticket(person,lock):
search(person)
lock.acquire() # 谁获得钥匙 谁才能进入
get_ticket(person)
lock.release() # 用完了，把钥匙给下一个人
if __name__ == '__main__':
lock = Lock() # 创建一个锁对象
for i in range(5):
p = Process(target=ticket,args=('person%s'%i,lock))
p.start() 结果：
person1查询余票： 3
person3查询余票： 3
person0查询余票： 3
person2查询余票： 3
person4查询余票： 3
person1买到票了
person3买到票了
person0买到票了
person2没买到票
person4没买到票 三、信号量 Semaphore
1、信号量的实现机制：计数器 + 锁实现的
信号量同步基于内部计数器，每调用一次acquire()，计数器减1；每调用一次release()，计数器加1.当计数器为0时，acquire()调用被阻塞。
互斥锁同时只允许一个线程更改数据，而信号量Semaphore是同时允许一定数量的线程更改数据(Samphore相当于有几把钥匙，lock只能有一把钥匙) import time
import random
from multiprocessing import Process
from multiprocessing import Semaphore def changba(person,sem): # 在唱吧 唱歌
sem.acquire() # 第一次可以同时进来两个人
print('%s走进唱吧' %person)
time.sleep(random.randint(3,6)) # 每个人唱歌的时间
print('%s走出唱吧' % person) # 唱完走人
sem.release() # 把钥匙给下一个人 if __name__ == '__main__':
sem = Semaphore(2) # 2把钥匙
for i in range(5):
p = Process(target=changba,args=('person%s' %i,sem))
p.start() 四、事件 Event
python线程的事件用于主线程控制其他线程的执行，事件主要提供了三个方法 set、wait、clear。
事件处理的机制：全局定义了一个“Flag”，如果“Flag”值为 False，那么当程序执行 event.wait 方法时就会阻塞，如果“Flag”值为True，那么event.wait 方法时便不再阻塞。 阻塞事件 ：wait()方法
wait是否阻塞是看event对象内部的Flag 控制Flag的值:
set() 将Flag的值改成True
clear() 将Flag的值改成False
is_set() 判断当前的Flag的值 红绿灯：
import time
import random
from multiprocessing import Process
from multiprocessing import Event def traffic_ligth(e): # 红绿灯
print('\033[31m红灯亮\033[0m') # Flag 默认是False
while True:
if e.is_set(): # 如果是绿灯
time.sleep(2) # 2秒后
print('\033[31m红灯亮\033[0m') # 转为红灯
e.clear() # 设置为False else: # 如果是红灯
time.sleep(2) # 2秒后
print('\033[32m绿灯亮\033[0m') # 转为绿灯
e.set() # 设置为True def car(e,i): # 车
if not e.is_set():
print('car %s在等待' %i)
e.wait()
print('car %s 通过了'%i) if __name__ == '__main__':
e = Event()
p = Process(target=traffic_ligth,args=(e,)) # 红绿灯进程
p.daemon = True
p.start()
p_lst = []
for i in range(10): # 10辆车的进程
time.sleep(random.randrange(0,3,2))
p = Process(target=car,args=(e,i))
p.start()
p_lst.append(p)
for p in p_lst:p.join()
五、总结
进程之间虽然内存不共享，但是是可以通信的
Lock Semaphore Event 都在进行进城之间的通信
只不过这些通信的内容我们不能改变
后续还有队列和管道能让进程之间进行通信