进程

进程

• 进程的三状态图

  • 就绪，运行，阻塞

  

• 进程的调度算法

  • 给所有进程分配资源或者CPU分配使用权的一种方法
    • 短作业有限
    • 先来先服务
    • 分时
    • 多级反馈算法（融合了以上三种）
      • 多个任务队列，优先级从高到底
      • 新来的任务总是优先级最高的
      • 每一个新任务几乎会立即获得一个时间片时间
      • 执行完一个时间片之后就会降级到下一个队列中
      • 总是优先级最高的任务都执行完才执行优先级低的队列
      • 并且优先级越高时片越短

• 进程的开启和关闭

  • 开启

    • 操作系统初始化
    • 一个进程在开启的过程中开启子进程（PyCharm中运行某个模块，注：父进程要负责在子进程结束之后回收资源）
    • 用户的交互式请求（点击某个程序的图标启动程序）
    • 无论哪一种，新进程的创建都是由一个已经存在的进程（此进程实用于创建进程）执行了而创建的新进程

  • 关闭

    • 正常退出
    • 出错退出
    • 被其他进程杀死

multiprocessing

• multiprocessing 多元的处理进程的模块

  • ret.terminate() 强制结束子进程

  • ret.is_alive() 判断子进程是否还活着

  • from multiprocessing import Process
    import os
    import time
    
    #面向函数编程
    def func():
        print(os.getpid(),os.getppid())
    
    if __name__ == '__main__':
        print('main:',os.getpid(), os.getppid())
        ret=Process(target=func)
        ret.start()
    得：
    main: 6736 14084
    6904 6736
    
    #面向对象编程
    class Myprocess(Process):
        def __init__(self,a,b,c):
            self.a=a
            self.b=b
            self.c=c
            super().__init__()
        def run(self):
            time.sleep(1)
            print(os.getpid(),os.getppid(),self.a,self.b,self.c)
    
    if __name__ == '__main__':
        print(os.getpid(),os.getppid())
        ret=Myprocess(1,2,3)
        ret.start()
        print(ret.is_alive())  #查看进程是否活着
        ret.terminate() #强制杀死子进程
        print(ret.is_alive())  #由于terminate是异步非阻塞所以还是True
        time.sleep(0.01)
        print(ret.is_alive())
    
    得：
    6236 14084
    True
    True
    False
    

• 给子进程传递参数，必须以元组的形式传递（name,）,注意：不能获取子进程的返回值

  • def func(name,age):
        print(os.getpid(),os.getppid(),name,age)
    
    if __name__ == '__main__':
        print('main:',os.getpid(), os.getppid())
        ret=Process(target=func,args=('liuliu',18))
        ret.start()
    得：
    main: 60 14084
    2316 60 liuliu 18
    

• 同时开启多个子进程（异步非阻塞）

  • def func(name,age):
        print(f'{name}start')
        time.sleep(1)
        print(os.getpid(),os.getppid(),name,age)
    
    if __name__ == '__main__':
        print('main:',os.getpid(), os.getppid())
        arg_lst = [('liuliu',18),('minmin', 17),('tongtong', 16)]
        for arg in arg_lst:
            ret=Process(target=func,args=arg)
            ret.start()
    main: 9040 14084
    minminstart
    liuliustart
    tongtongstart
    5968 9040 minmin 17
    13896 9040 liuliu 18
    8996 9040 tongtong 16
    

• join 执行完所有start（异步非阻塞）进程后在执行join（同步阻塞）下面的代码

  • def func(name,age):
        print(f'给{name}发送邮件完毕')
    if __name__ == '__main__':
        arg_lst = [('liuliu',18),('minmin', 17),('tongtong', 16)]
        ret_l=[]
        for arg in arg_lst:
            ret=Process(target=func,args=arg)
            ret.start()
            ret_l.append(ret)
        for i in ret_l:i.join()
        print('所有邮件发送完毕')
    得：
    给minmin发送邮件完毕
    给tongtong发送邮件完毕
    给liuliu发送邮件完毕
    所有邮件发送完毕
    

• 使用多进程实现并发得server端

  • server

    import socket
    from multiprocessing import Process
    
    
    def func(conn):
        while True:
            r = conn.recv(1024).decode('utf-8')
            msg = r.upper().encode('utf-8')
            conn.send(msg)
        conn.close()
    
    if __name__ == '__main__':
        sk = socket.socket()
        sk.bind(('127.0.0.1', 1235))
        sk.listen()
        while True:
            conn, addr = sk.accept()
            ret=Process(target=func,args=(conn,)).start()
    
        sk.close()
    

  • client

    import time
    import socket
    
    sk=socket.socket()
    sk.connect(('127.0.0.1',1235))
    
    while True:
        sk.send(b'hello')
        msg=sk.recv(1024).decode('utf-8')
        print(msg)
        time.sleep(0.5)
    sk.close()
    

• 守护进程

  • 主进程会等所有子进程结束，是为了回收子进程得资源

  • 守护进程会等到主进程的代码结束后在结束，而不是等待整个主进程结束

  • 主进程的 代码什么时候结束，守护进程就什么时候结束，和其他子进程的执行速度无关

  • ret.daemon=True #表示ret是一个守护进程，必须现在start上面

  • from multiprocessing import Process
    import time
    
    def son1():
        while True:
            time.sleep(0.1)
            print('in son1')
    
    def son2():
        for i in range(10):
            print('in son2')
    
    if __name__ == '__main__':
        ret=Process(target=son1)
        ret.daemon=True  #表示ret是一个守护进程，必须现在start上面
        ret.start()
        ret2=Process(target=son2)
        ret2.start()
        time.sleep(2)
        ret2.join()  #等待ret2结束之后守护进程在结束
        print('结束')