标签：multi 先来 lock 获取 self 自定义 策略 发热 同步
1）进程就是正在运行的程序,它是操作系统中,资源分配的最小单位
（1）资源分配:分配的是cpu和内存等物理资源
（2）进程号是进程的唯一标识
2）同一个程序执行两次之后是两个进程
3）进程和进程之间的关系: 数据彼此隔离,通过socket通信
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 """
等待子进程执行完毕之后，主进程再向下执行
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同一时间不停执行多个程序
（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... ... """
标签：multi 先来 lock 获取 self 自定义 策略 发热 同步
原文地址：https://www.cnblogs.com/wangzihong/p/11405047.html
