进程（Process）
1）进程就是正在运行的程序,它是操作系统中,资源分配的最小单位
（1）资源分配:分配的是cpu和内存等物理资源
（2）进程号是进程的唯一标识
2）同一个程序执行两次之后是两个进程
3）进程和进程之间的关系: 数据彼此隔离,通过socket通信
获取进程id
import os res = os.getpid() # 获取当前进行id （当前子进程） print(res) res = os.getppid() # 获取父进程id print(res) # result """ 13724 13800 """
进程的基本用法
from multiprocessing import Process
import time
import os
def func():
print("S2>>>当前子进程id:%s,它的父进程id:%s" %(os.getpid(),os.getppid()))
if __name__ == "__main__":
print("S1>>>子进程id：%s，父进程id：%s"%(os.getpid(),os.getppid()))
p = Process(target=func) # 创建子进程 target = 函数 单独用一个进程去执行谁,去完成哪个任务
p.start() # 调用子进程
# result
"""
S1>>>子进程id：7576，父进程id：13800
S2>>>当前子进程id:7100,它的父进程id:7576
"""
带有参数的函数
异步程序：不等没一行代码执行完毕，就往下执行其它代码
from multiprocessing import Process
import time
import os
def func():
for i in range(1,5):
print("S2>>>当前子进程id：%s，它的父进程id：%s"%(os.getpid(),os.getppid()))
if __name__ == "__main__":
print("S1>>>子进程id：%s，父进程id：%s"%(os.getpid(),os.getppid()))
p = Process(target=func)
p.start()
n = 5
for i in range(1,n+1):
print("*" * i )
# result
"""
S1>>>子进程id：7928，父进程id：13800
*
**
***
****
*****
S2>>>当前子进程id：8112，它的父进程id：7928
S2>>>当前子进程id：8112，它的父进程id：7928
S2>>>当前子进程id：8112，它的父进程id：7928
S2>>>当前子进程id：8112，它的父进程id：7928
"""
进程之间数据，彼此隔离
from multiprocessing import Process
import time
import os
count = 99
def func():
global count
count += 1
print("当前子进程id:%s"%(os.getpid()),count)
if __name__ == "__main__":
p = Process(target=func)
p.start()
time.sleep(1) # 让子进程跑完，看是否通过子进程修改
print("主进程",count)
# result
"""
当前子进程id:1956 100
主进程 99
"""
多进程之间的并发
多程序并发时，因为cpu的调度策略，任务的执行是互相抢占cpu资源的过程
from multiprocessing import Process
import time
import os
def func(args):
print("S2>>>当前子进程id:%s，它的父进程id：%s"%(os.getpid(),os.getppid()))
print("end>>>",args)
if __name__ == "__main__":
for i in range(10):
Process(target=func,args=(i,)).start()
print("主进程执行结束...")
# result
"""
主进程执行结束...
S2>>>当前子进程id:10376，它的父进程id：9932
end>>> 2
S2>>>当前子进程id:13476，它的父进程id：9932
end>>> 1
S2>>>当前子进程id:11812，它的父进程id：9932
end>>> 3
S2>>>当前子进程id:13936，它的父进程id：9932
end>>> 4
S2>>>当前子进程id:2384，它的父进程id：9932
end>>> 7
S2>>>当前子进程id:7024，它的父进程id：9932
end>>> 5
S2>>>当前子进程id:14284，它的父进程id：9932
end>>> 8
S2>>>当前子进程id:4816，它的父进程id：9932
end>>> 9
S2>>>当前子进程id:120，它的父进程id：9932
end>>> 6
S2>>>当前子进程id:8604，它的父进程id：9932
end>>> 0
"""
主进程和子进程之间的关系
（1）主进程执行完所有代码，等待子进程全部结束，再终止程序
（2）不等待，子进程变成僵尸用户，在后台不停运行，耗费资源
from multiprocessing import Process
import time
import os
def func(args):
print("S2>>>当前子进程id：%s，它的父进程id：%s"%(os.getpid(),os.getppid()))
time.sleep(0.1)
print("end>>>",args)
if __name__ == "__main__":
for i in range(10):
Process(target=func,args=(i,)).start()
print("主进程执行结束...")
# result
"""
主进程执行结束...
S2>>>当前子进程id：10092，它的父进程id：6304
S2>>>当前子进程id：11220，它的父进程id：6304
S2>>>当前子进程id：12992，它的父进程id：6304
S2>>>当前子进程id：8384，它的父进程id：6304
S2>>>当前子进程id：3824，它的父进程id：6304
S2>>>当前子进程id：12880，它的父进程id：6304
S2>>>当前子进程id：6352，它的父进程id：6304
end>>> 0
end>>> 2
S2>>>当前子进程id：7160，它的父进程id：6304
end>>> 9
end>>> 7
S2>>>当前子进程id：6676，它的父进程id：6304
end>>> 5
end>>> 8
end>>> 3
S2>>>当前子进程id：7488，它的父进程id：6304
end>>> 1
end>>> 6
end>>> 4
"""
join
等待子进程执行完毕之后，主进程再向下执行
基本用法
from multiprocessing import Process
import time
import os
def func():
print("发送第一封邮件")
if __name__ == "__main__":
p = Process(target=func)
p.start()
time.sleep(1)
p.join() # 针对于p进程对象来说,必须等待p这个进程任务执行完毕之后,主进程的代码在向下执行
print("发送第二封邮件")
# result
"""
发送第一封邮件
发送第二封邮件
"""
多个子进程
多个子进程通过join加阻塞，可以实现同步控制
from multiprocessing import Process
import time
import os
def func(index):
print("第%s封邮件发送..."%(index))
if __name__ == "__main__":
lst = [] # 初始化一个列表
for i in range(5):
p = Process(target=func,args=(i,))
p.start()
lst.append(p)
p.join()
# 循环列表中每一个进程，都加上join，保证每个子进程执行完毕，保证同步性
for i in lst:
i.join()
print("发送最后一封邮件...")
# result
"""
第0封邮件发送...
第1封邮件发送...
第2封邮件发送...
第3封邮件发送...
第4封邮件发送...
发送最后一封邮件...
"""
自定义类方式创建进程
基本用法
from multiprocessing import Process
import time
import os
class MyProcess(Process): # 必须继承父类Process
def run(self): # 必须写成run方法
print(">>>子进程id：%s，父进程id：%s"%(os.getpid(),os.getppid()))
if __name__ == "__main__":
p = MyProcess()
p.start()
print(">>>主进程id：%s"%(os.getpid()))
# result
"""
>>>主进程id：9988
>>>子进程id：14248，父进程id：9988
"""
带参数子进程函数
from multiprocessing import Process
import time
import os
class MyProcee(Process):
def __init__(self,arg):
super().__init__() # 必须调用一下父类的构造方法
self.arg = arg
def run(self):
print(">>>子进程id：%s，父进程id：%s"%(os.getpid(),os.getppid()))
print(self.arg)
if __name__ == "__main__":
lst = []
for i in range(10):
p = MyProcee("参数：%s"%(i))
p.start()
lst.append(p)
for i in lst:
i.join()
print("最后打印子进程id",os.getppid())
# result
"""
>>>子进程id：7488，父进程id：8596
参数：6
>>>子进程id：11300，父进程id：8596
参数：8
>>>子进程id：12048，父进程id：8596
参数：4
>>>子进程id：7868，父进程id：8596
参数：0
>>>子进程id：4792，父进程id：8596
参数：5
>>>子进程id：10764，父进程id：8596
参数：2
>>>子进程id：10852，父进程id：8596
参数：1
>>>子进程id：9348，父进程id：8596
参数：3
>>>子进程id：9860，父进程id：8596
参数：7
>>>子进程id：8956，父进程id：8596
参数：9
最后打印子进程id 13800
"""
并行和并发
（1）并行：一个cpu同一时间不停执行多个程序
（2）并发：多个cpu同一时间不停执行多个程序
cpu的进程调度方法
（1）先来先服务fcfs(first come first server):先来的先执行
（2）短作业优先算法:分配的cpu多,先把短的算完
（3）时间片轮转算法:每一个任务就执行一个时间片的时间.然后就执行其他的
（4）多级反馈队列算法
越是时间长的,cpu分配的资源越短,优先级靠后，越是时间短的,cpu分配的资源越多
进程三状态图
（1）就绪(Ready)状态-->只剩下CPU需要执行外,其他所有资源都已分配完毕 称为就绪状态。
（2）执行(Running)状态 --> cpu开始执行该进程时称为执行状态
（3）阻塞(Blocked)状态 --> 由于等待某个事件发生而无法执行时,便是阻塞状态,cpu执行其他进程.例如，等待I/O完成input、申请缓冲区不能满足等
同步|异步/阻塞|非阻塞
场景在多任务中
同步：必须等我这件事干完了,你在干,只有一条主线,就是同步
异步：没等我这件事情干完,你就在干了,有两条主线,就是异步
阻塞：比如代码有了input,就是阻塞,必须要输入一个字符串,否则代码不往下执行
非阻塞：没有任何等待,正常代码往下执行
同步阻塞：效率低,cpu利用不充分
异步阻塞：比如socketserver,可以同时连接多个,但是彼此都有recv
同步非阻塞：没有类似input的代码,从上到下执行.默认的正常情况代码
异步非阻塞：效率是最高的,cpu过度充分,过度发热
守护进程
可以给子进程贴上守护进程的名字,该进程会随着主进程代码执行完毕而结束(为主进程守护)
（1）守护进程会在主进程代码执行结束后就终止
（2）守护进程内无法再开启子进程,否则抛出异常(了解)
基本用法
from multiprocessing import Process
import time
import os
def func():
print("子进程start...")
time.sleep(0.1)
print("子进程end...")
if __name__ == "__main__":
p = Process(target=func)
p.daemon = True # 在start开始前设置该进程为守护进程
p.start()
print("主进程执行结束...")
# result
"""
主进程执行结束...
"""
多个子进程
（1）当主进程里面的代码全部执行完毕，守护进程自动终止
（2）func1是守护进程，func2是非守护进程
from multiprocessing import Process
import time
import os
def func1():
count = 1
while True:
print("*" * count)
time.sleep(0.5)
count += 1
def func2():
print("func2 start...")
time.sleep(2)
print("func2 end...")
if __name__ == "__main__":
p1 = Process(target=func1)
p1.daemon = True
p2 = Process(target=func2)
p1.start()
p2.start()
time.sleep(1)
print("主进程代码执行完毕...")
# result
"""
func2 start...
*
**
主进程代码执行完毕...
func2 end...
"""
守护进程应用--报活
from multiprocessing import Process
import time
import os
def alive():
while True:
print("一号服务主机ok...")
time.sleep(1) # 相隔1秒报活
def func():
print("一号服务主机负责统计日志信息")
time.sleep(3)
if __name__ == "__main__":
p1 = Process(target=alive)
p1.daemon = True
p1.start()
p2 = Process(target=func)
p2.start()
p2.join() # join添加阻塞，join执行结束，代表服务统计功能失败
print(" ... ")
# result
"""
一号服务主机ok...
一号服务主机负责统计日志信息
一号服务主机ok...
一号服务主机ok...
一号服务主机ok...
...
"""