2019-04-15-day032-多进程介绍

内容回顾

1. 基于原生socket的udp协议实现将client端发送过来的消息放到字典中
2. 字典的key是所有客户端的地址,value是一个列表
3. io :输入输出,
   • 输入到内存,向内存输入
   • 从内存中向外(硬盘,网络)输出
4. 操作系统的发展史
   • 多道操作系统
   • 分时操作系统
5. 并发和并行
   • 并发 : 多个程序在一个cpu上交替运行
   • 并行 : 在多个cpu上同时有多个程序在执行
6. 阻塞和非阻塞
   • 指CPU是否在工作
   • 在工作 :非阻塞
   • 不在工作 :阻塞
7. 同步和异步
   • 调一个任务,需要等待这个任务执行完并返回结果,现在的代码才能继续
   • 调一个任务,不关心这个任务是否执行是否完毕,只负责调用,余下的内容和我当前的代码时各自执行的
8. 进程和程序
   • 运行中的程序
   • 是计算机中最小的资源分配单位
   • 多个进程之间的数据互相隔离
   • pid能够在操作系统中唯一标识一个进程
9. 进程的三状态图 : 就绪 运行 阻塞
10. 进程的创建和结束
11. 进程的调度
    • 先来先服务
    • 短作业优先
    • 分时/多道
    • 多级反馈队列

减少阻塞

阻塞

• 登录
• input()
• input()
• 判断用户名密码

非阻塞

import sys
print(sys.argv)
if sys.argv[1] == 'alex' and sys.argv[2] == 'alex3714':
    print('登录成功')

Process类

import os
import time
def func(i):
    time.sleep(5)
    print(i,os.getpid())
print('主 :',os.getpid())
func(0)
func(1)
func(2)

使用Process类创建一个子进程

import os
import time
from multiprocessing import Process
def func(a,b,c):
    time.sleep(1)
    print(a,b,c,os.getpid(),os.getppid())
    * pid : processid   ppid : parent process id

Process进程类

if __name__ == '__main__':
    * windows操作系统下开启子进程子进程中的代码是通过import这种方式被导入到子进程中的
    print('主 :', os.getpid())
    Process(target=func,args=(1,2,3)).start()
    * Process(target=func).start()
    * Process(target=func).start()

几个概念

• 子进程
• 父进程
• 主进程

if __name__ == '__main__'

• func的参数怎么传递
• func的返回值能返回到父进程中么? 不行
• 进程之间数据隔离,所以子进程中的返回值父进程获取不到

进程中的其他几个方法

import os
import time
from multiprocessing import Process
def func(a,b,c):
    time.sleep(1)
    print(a,b,c,os.getpid(),os.getppid())

Process进程类

if __name__ == '__main__':
    p = Process(target=func,args=(1,2,3))
    p.start()   * p是一个进程操作符
    print(p.is_alive())
    p.terminate()  * 异步非阻塞
    print(p.is_alive())
    time.sleep(0.1)
    print(p.is_alive())
    print(p.name)
    print(p.pid)

如何开启多个子进程

import os
import time
from multiprocessing import Process
def func(a,b,c):
    time.sleep(1)
    print(a,b,c,os.getpid(),os.getppid())
if __name__ == '__main__':
    * Process(target=func,args=(1,2,3)).start()
    * Process(target=func,args=(2,3,4)).start()
    * Process(target=func,args=(3,4,5)).start()
    for i in  range(1,4):
        Process(target=func, args=(i, i+1, i+2)).start()

join

import time
import random
from multiprocessing import Process

def send_mail(name):
    time.sleep(random.uniform(1,3))
    print('已经给%s发送邮件完毕'%name)

if __name__ == '__main__':
    lst = ['alex','yuan','宝元','太白']
   * 阻塞等待一个子进程结束
   * p = Process(target=send_mail, args=('alex',))
   * p.start()
   * p.join()   * 阻塞,直到p对应的进程结束之后才结束阻塞
   * print('所有的信息都发送完毕了')

   * p_l = []
   * for name in lst:
   *     p = Process(target=send_mail,args=(name,))
   *     p.start()
   *     p_l.append(p)
   * for p in p_l : p.join()
   * print('所有的信息都发送完毕了')

守护进程

import time
from multiprocessing import Process
def func():
   for i in range(20):
       time.sleep(0.5)
       print('in func')

def func2():
   print('start : func2')
   time.sleep(5)
   print('end : func2')

if __name__ == '__main__':
   p = Process(target=func)
   p.daemon = True   * 表示设置p为一个守护进程
   p.start()
   p2 =Process(target=func2)
   p2.start()
   print('in main')
   time.sleep(3)
   print('finished')
   p2.join()

• 主进程和子进程互不干扰
• 主进程执行完毕之后程序不会结束,会等待所有的子进程结束之后才结束
• 为什么主进程要等待子进程结束之后才结束?
  • 因为主进程要负责给子进程回收一些系统资源
• 守护进程 :
  • 是一个子进程,守护的是主进程
  • 结束条件 : 主进程的代码结束,守护进程也结束
• 进程
  • 主进程的代码结束,守护进程结束
  • 主进程要回收守护进程(子进程)的资源
  • 主进程等待其他所有子进程结束
  • 主进程回收所有子进程的资源

Process类的总结

1. 开启子进程
   • tartget
   • args
   • if name == '__main__'
   • start()
2. 其他的方法
   • 方法 :
     • terminate()
     • is_alive()
   • 属性
     • pid
     • name
3. 开启多个子进程
4. join
   • 阻塞等待一个子进程结束
   • 阻塞等待多个子进程结束
5. 守护进程
   • daemon
6. 面向对象的方式实现多进程

import os
from multiprocessing import Process
class MyProcess(Process):
    def run(self):   # 希望在子进程中执行的代码就放在run方法中
        print(os.getpid())

if __name__ == '__main__':
    for i in range(10):
        MyProcess().start()

import os
from multiprocessing import Process
class MyProcess(Process):
    def __init__(self,a,b):
        super().__init__()
        self.a = a
        self.b = b

    def run(self):   # 希望在子进程中执行的代码就放在run方法中
        print(os.getpid(),self.a,self.b)
        self.func()
if __name__ == '__main__':
    for i in range(10):
        MyProcess(1,2).start()   # 通知操作系统开进程,执行run方法

• 明天要默写
  1. 内容回顾的概念
  2. 使用multiprocess起一个最简单的子进程,执行查看子进程的进程id
  3. 使用多进程实现socket tcp协议的并发server端(博客上有答案)