Python 之并发编程之进程上(基本概念、并行并发、cpu调度、阻塞 )
一： 进程的概念:(Process)
进程就是正在运行的程序,它是操作系统中,资源分配的最小单位.
资源分配:分配的是cpu和内存等物理资源
进程号是进程的唯一标识
同一个程序执行两次之后是两个进程
进程和进程之间的关系: 数据彼此隔离,通过socket通信
二：并行和并发
并发:一个cpu同一时间不停执行多个程序
并行:多个cpu同一时间不停执行多个程序
三：cpu的进程调度方法
# 先来先服务fcfs(first come first server):先来的先执行
# 短作业优先算法:分配的cpu多,先把短的算完
# 时间片轮转算法:每一个任务就执行一个时间片的时间.然后就执行其他的.
# 多级反馈队列算法
越是时间长的,cpu分配的资源越短,优先级靠后
越是时间短的,cpu分配的资源越多
### 进程三状态图
(1)就绪(Ready)状态
只剩下CPU需要执行外,其他所有资源都已分配完毕 称为就绪状态。
(2)执行(Running)状态
cpu开始执行该进程时称为执行状态。
(3)阻塞(Blocked)状态
由于等待某个事件发生而无法执行时,便是阻塞状态,cpu执行其他进程.例如，等待I/O完成input、申请缓冲区不能满足等等。
这三个在下面学习的内容中是一起掺杂在一起的
（1）获取进程号
使用os.getpid() 获取子进程号
使用os.getppid() 获取父进程号
#例：
import os, time # 获取子进程[当前进程]的id号 res1 = os.getpid() print(res1) # 获取父进程的id号 res2 = os.getppid() print(res2) # linux Process 底层利用的是fork来创建进程的,而fork在windows里并不支持.
#如果在编辑器上运行可知，父进程号是不变得，子进程号是改变的，因为父进程号是编辑器运行的进程号，二子进程号是这个程序运行的进程号，程序重新运行子进程重启在启动一个。
（2）进程的基本用法
例：
import os from multiprocessing import Process def func(): print("1.子进程id>>>%s,父进程id>>>%s" %(os.getpid(),os.getppid())) if __name__ == "__main__": print("2.子进程id>>>%s,父进程id>>>%s" % (os.getpid(), os.getppid())) #创建子进程，返回一个进程对象.target是指定要完成的任务，后面接的是函数 p = Process(target = func) # 调用子进程 p.start()
结果是：函数外的父进程号是不变的，子进程号和函数内的父进程号是相同的，而且每次运行进程号是在改变的，函数内的子进程号每次也是改变的。
（3）函数中带有参数
进程的并发要依靠cpu
cpu先执行谁后执行谁,要依靠cpu调度策略
# 无参函数
#例：
from multiprocessing import Process import os def func(): for i in range(1,6): print("2.子进程id>>>%s,父进程id>>>%s" %(os.getpid(),os.getppid())) if __name__ == "__main__": print("1.子进程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)
#先打印星星后打印func函数内的循环,因为创建子进程中需要开辟栈帧空间需要时间
效果截图：
# 有参函数
from multiprocessing import Process import os,time def func(n): for i in range(1,n+1): time.sleep(0.5) print("2.子进程id>>>%s,父进程id>>>%s" % (os.getpid(), os.getppid())) if __name__ == "__main__": print("1.子进程id>>>%s,父进程id>>>%s" % (os.getpid(), os.getppid())) n = 5 # 创建子进程 返回进程对象 如果有参数用args 关键字参数执行 # 对应的值是元组,参数塞到元组中,按照次序排列 p = Process(target=func,args=(n,)) p.start() for i in range(1,n+1): time.sleep(0.3) print("*" * i)
# 这时候会造成,星星和func里面打印子进程和父进程的语句相互交错
# 因为子进程开辟栈帧空间的时间极短,所有再哪个不在睡眠时间内先运行哪个进程
效果截图：
（4）进程之间的数据彼此是隔离的
#例：
from multiprocessing import Process count = 99 def func(): global count count +=1 print("我是子进程,count=",count) if __name__ == "__main__": p = Process(target=func) p.start() print("我是主进程,count=",count)
结果输出为：
我是主进程,count= 99
我是子进程,count= 100
（5）多个进程的并发
#例：
# 在程序并发时, 因为cpu的调度策略问题,不一定谁先执行,谁后执行 from multiprocessing import Process import os def func(args): print("args=%s,子进程id号>>>%s, 父进程id号>>>%s" % (args, os.getpid(), os.getppid())) if __name__ == "__main__": for i in range(10): Process(target=func, args=(i,)).start()
运行得到结果如下图：
可以看出父进程id号是不变的，子进程id号是变化的，而且子进程开启不是按顺序的是并发的。
(6)子进程和父进程之间的关系
通常情况下,父进程会比子进程速度稍快,但是不绝对
在父进程执行所有代码完毕之后,会默认等待所有子进程执行完毕
然后在彻底的终止程序,为了方便进程的管理
如果不等待,子进程会变成僵尸进程,在后台不停地占用内存和cpu资源
但是本身由于进程太多,并不容易发现
#例：
from multiprocessing import Process import os,time def func(args): print("args=%s,子进程id号>>>%s,父进程id号>>>%s" % (args, os.getpid(), os.getppid())) time.sleep(1) print("args= %s, end" % (args)) if __name__ == "__main__": for i in range(10): Process(target=func,args=(i,)).start() """ Process(target=func,args=(i,)).start() Process(target=func,args=(i,)).start() Process(target=func,args=(i,)).start() Process(target=func,args=(i,)).start() Process(target=func,args=(i,)).start() Process(target=func,args=(i,)).start() .... """ print("*******父进程*******")
运行后的结果为：
可以看出父进程号是不变的，子进程是并发的，父进程的执行语句是最快结束的，因为开启子进程需要时间，而主进程的输出没有阻塞所以最快，从print("args= %s, end" % (args))可以知道，子进程是并发的，因为sleep(1)后，如果是顺序执行的话，输出结果不是这样。
四：同步 异步 / 阻塞 非阻塞
场景在多任务当中
同步:必须等我这件事干完了,你在干,只有一条主线,就是同步
异步:没等我这件事情干完,你就在干了,有两条主线,就是异步
阻塞:比如代码有了input,就是阻塞,必须要输入一个字符串,否则代码不往下执行
非阻塞:没有任何等待,正常代码往下执行.
# 同步阻塞 :效率低,cpu利用不充分
# 异步阻塞 :比如socketserver,可以同时连接多个,但是彼此都有recv
# 同步非阻塞:没有类似input的代码,从上到下执行.默认的正常情况代码
# 异步非阻塞:效率是最高的,cpu过度充分,过度发热
（1）join阻塞基本用法
#例：
from multiprocessing import Process def func(): print("我发送第一封邮件....") if __name__ == "__main__": p = Process(target=func) p.start() # 等待p对象的这个子进程执行完毕之后,在向下执行代码 # join实际上是加了阻塞 p.join() #如果没有join,往往主进程先运行,因为子进程需要开辟栈帧空间相当于加了阻塞 print("发送第十封邮件")
输出结果为：
我发送第一封邮件....
发送第十封邮件
#程序在发送第十封邮件前加了阻塞，是的会先运行子进程结束在运行join之后的语句
(2) 多个子进程通过join 加阻塞,进行同步的控制
例：
from multiprocessing import Process import time def func(index): time.sleep(0.3) print("第%s封邮件已经发送..." % (index)) if __name__ == "__main__": lst = [] for i in range(1,10): p = Process(target=func,args=(i,)) p.start() lst.append(p) # 把列表里面的每一个进程对象去执行join() # 必须等我子进程执行完毕之后了,再向下执行,控制父子进程的同步性 for i in lst: i.join() # 等前9个邮件发送之后了,再发第十个 print("发送第十封邮件")
所以输出结果为：
第3封邮件已经发送...
第2封邮件已经发送...
第1封邮件已经发送...
第5封邮件已经发送...
第9封邮件已经发送...
第6封邮件已经发送...
第4封邮件已经发送...
第7封邮件已经发送...
第8封邮件已经发送...
发送第十封邮件
十个子进程是并发的，所以不一定谁先执行结束，所以不是顺序的。
（3）使用类的方法创建子进程
# (1) 基本语法
可以使用自定义的方式创建子进程,
但是必须继承父类Processs
而且所有的逻辑都必须写在run方法里面
#例：
from multiprocessing import Process import os class MyProcess(Process): # 必须使用叫做run的方法,而且()里面只能是self def run(self): # 写自定义的逻辑 print("子进程id>>>%s, 父进程的id>>>%s" % (os.getpid(), os.getppid())) if __name__ == "__main__": p = MyProcess() p.start() print("主进程:{}".format(os.getpid()))
输出结果为：
主进程:8236
子进程id>>>6412, 父进程的id>>>8236
# (2) 带参数的子进程函数
#例：
from multiprocessing import Process import os class MyProcess(Process): def __init__(self,arg): # 必须调用一下父类的初始化构造方法 super().__init__() self.arg = arg # 必须使用叫做run的方法 def run(self): # 在这里就得获取参数 print("子进程id>>>%s,父进程的id>>>%s" % (os.getpid(),os.getppid())) print(self.arg) if __name__ == "__main__": lst = [] for i in range(1,10): p = MyProcess("参数:%s" % (i)) p.start() lst.append(p) for i in lst: i.join() print("最后执行主进程的这句话...",os.getpid())
运行结果为：
子进程id>>>5964,父进程的id>>>5336
参数:2
子进程id>>>10544,父进程的id>>>5336
参数:3
子进程id>>>11512,父进程的id>>>5336
参数:4
子进程id>>>11160,父进程的id>>>5336
参数:5
子进程id>>>12068,父进程的id>>>5336
参数:1
子进程id>>>5288,父进程的id>>>5336
参数:6
子进程id>>>11380,父进程的id>>>5336
参数:8
子进程id>>>8092,父进程的id>>>5336
参数:7
子进程id>>>7120,父进程的id>>>5336
参数:9
最后执行主进程的这句话... 5336
结果分析：父进程是程序运行的主进程号不变，子进程是并发的所以那个参数先打印是不固定的，然后对每个子进程添加了join阻塞，所以没有全部执行完子进程之前，主进程的运行语句是不打印的，也就是在子进程join后主进程运行语句必须等待子进程全部结束才打印。
