python进程|线程|协程，,进程（Process

python进程|线程|协程，,进程（Process

进程（Process）

　　1）进程就是正在运行的程序,它是操作系统中,资源分配的最小单位

　　（1）资源分配:分配的是cpu和内存等物理资源

　　（2）进程号是进程的唯一标识

　　2）同一个程序执行两次之后是两个进程

　　3）进程和进程之间的关系: 数据彼此隔离,通过socket通信

获取进程id

import osres = os.getpid() # 获取当前进行id （当前子进程）print(res)res = os.getppid() # 获取父进程idprint(res)# result """1372413800"""

进程的基本用法

from multiprocessing import Processimport timeimport osdef 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：13800S2>>>当前子进程id:7100,它的父进程id:7576"""

带有参数的函数

　　异步程序：不等没一行代码执行完毕，就往下执行其它代码

from multiprocessing import Processimport timeimport osdef 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：7928S2>>>当前子进程id：8112，它的父进程id：7928S2>>>当前子进程id：8112，它的父进程id：7928S2>>>当前子进程id：8112，它的父进程id：7928"""

进程之间数据，彼此隔离

from multiprocessing import Processimport timeimport oscount = 99def 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 Processimport timeimport osdef 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：9932end>>> 2S2>>>当前子进程id:13476，它的父进程id：9932end>>> 1S2>>>当前子进程id:11812，它的父进程id：9932end>>> 3S2>>>当前子进程id:13936，它的父进程id：9932end>>> 4S2>>>当前子进程id:2384，它的父进程id：9932end>>> 7S2>>>当前子进程id:7024，它的父进程id：9932end>>> 5S2>>>当前子进程id:14284，它的父进程id：9932end>>> 8S2>>>当前子进程id:4816，它的父进程id：9932end>>> 9S2>>>当前子进程id:120，它的父进程id：9932end>>> 6S2>>>当前子进程id:8604，它的父进程id：9932end>>> 0"""

主进程和子进程之间的关系

（1）主进程执行完所有代码，等待子进程全部结束，再终止程序

（2）不等待，子进程变成僵尸用户，在后台不停运行，耗费资源

from multiprocessing import Processimport timeimport osdef 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：6304S2>>>当前子进程id：11220，它的父进程id：6304S2>>>当前子进程id：12992，它的父进程id：6304S2>>>当前子进程id：8384，它的父进程id：6304S2>>>当前子进程id：3824，它的父进程id：6304S2>>>当前子进程id：12880，它的父进程id：6304S2>>>当前子进程id：6352，它的父进程id：6304end>>> 0end>>> 2S2>>>当前子进程id：7160，它的父进程id：6304end>>> 9end>>> 7S2>>>当前子进程id：6676，它的父进程id：6304end>>> 5end>>> 8end>>> 3S2>>>当前子进程id：7488，它的父进程id：6304end>>> 1end>>> 6end>>> 4"""

join

　　等待子进程执行完毕之后，主进程再向下执行

基本用法

from multiprocessing import Processimport timeimport osdef func():    print("发送第一封邮件")if __name__ == "__main__":    p = Process(target=func)    p.start()    time.sleep(1)    p.join() # 针对于p进程对象来说,必须等待p这个进程任务执行完毕之后,主进程的代码在向下执行    print("发送第二封邮件")    # result """发送第一封邮件发送第二封邮件"""

多个子进程

　　多个子进程通过join加阻塞，可以实现同步控制

from multiprocessing import Processimport timeimport osdef 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 Processimport timeimport osclass 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 Processimport timeimport osclass 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 Processimport timeimport osdef 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 Processimport timeimport osdef func1():    count = 1    while True:        print("*" * count)        time.sleep(0.5)        count += 1def 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 Processimport timeimport osdef 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... ... """

python进程|线程|协程