python精选22集（多任务、进程、进程池）

一.多任务介绍

• 现实生活中

有很多的场景中的事情是同时进行的，比如开车的时候 手和脚共同来驾驶汽车，再比如唱歌跳舞也是同时进行的；

试想，如果把唱歌和跳舞这2件事情分开依次完成的话，估计就没有那么好的效果了

• 程序中
  如下程序，来模拟“唱歌跳舞”这件事情

from time import sleep
def sing():
    for i in range(3):
        print("正在唱歌...%d"%i)
        sleep(1)

def dance():
    for i in range(3):
        print("正在跳舞...%d"%i)
        sleep(1)

if __name__ == '__main__':
    sing() #唱歌
    dance() #跳舞

很显然刚刚的程序并没有完成唱歌和跳舞同时进行的要求 如果想要实现“唱歌跳舞”同时进行，那么就需要一个新的方法，叫做：多任务

二.多任务概念

什么叫“多任务”呢？简单地说，就是操作系统可以同时运行多个任务。打个比方，你一边在用浏览器上网，一边在听MP3，一边在用Word赶作业，这就是多任务，至少同时有3个任务正在运行。还有很多任务悄悄地在后台同时运行着，只是桌面上没有显示而已。

1.意义

• 充分利用计算机多核资源，提高程序的运行效率。

2.实现方案

• 多进程 ， 多线程

3.并行与并发

 并发 ： 同时处理多个任务，内核在任务间不断的切换达到好像多个任务被同时执行的效果，实际每个时刻只有一个任务占有内核。
 并行 ：多个任务利用计算机多核资源在同时执行，此时多个任务间为并行关系。

通俗理解将下图线程理解为任务即可

三.进程

1.定义

• 程序在计算机中的一次运行。
  • 程序是一个可执行的文件，是静态的占有磁盘。
  • 进程是一个动态的过程描述，占有计算机运行资源，有一定的生命周期。

2.系统中如何产生一个进程

• 1.用户空间通过调用程序接口或者命令发起请求
• 2.操作系统接收用户请求，开始创建进程
• 3.操作系统调配计算机资源，确定进程状态等
• 4.操作系统将创建的进程提供给用户使用

3.基本概念

 cpu时间片：如果一个进程占有cpu内核则称这个进程在cpu时间片上。
PCB(进程控制块)：在内存中开辟的一块空间，用于存放进程的基本信息，也用于系统查找识别进程。
进程ID（PID）： 系统为每个进程分配的一个大于0的整数，作为进程ID。每个进程ID不重复。

• Linux查看进程ID ： ps -aux

S 等待态
R 执行态
D 等待态
T 等待态
Z 僵尸

<  有较高优先级
N  优先级较低
+  前台进程
s  会话组组长
l  有多线程的

* USER ： 进程的创建者
* PID  :  操作系统分配给进程的编号,大于0的整数，系统中每个进程的PID都不重复。PID也是重要的区分进程的标志。
* %CPU,%MEM : 占有的CPU和内存
* STAT ： 进程状态信息，S I 表示阻塞状态  ，R 表示就绪状态或者运行状态
* START : 进程启动时间
* COMMAND : 通过什么程序启动的进程

• 父子进程 ：

   系统中每一个进程(除了系统初始化进程)都有唯一的父进程，可以有0个或多个子进程。父子进程关系便于进程管理。
  

• 查看进程树： pstree

4.进程状态

• 三态

  	就绪态 ： 进程具备执行条件，等待分配cpu资源
  
  	运行态 ： 进程占有cpu时间片正在运行
  
  	等待态 ： 进程暂时停止运行，让出cpu
  

• 五态
  (在三态基础上增加新建和终止)
  新建 ： 创建一个进程，获取资源的过程
  终止 ： 进程结束，释放资源的过程

5.运行特征

1 进程可以使用计算机多核资源

2 进程是计算机分配资源的最小单位

3 进程之间的运行互不影响，各自独立

4 每个进程拥有独立的空间，各自使用自己空间资源

四.多进程编程

1.multiprocessing 模块创建进程

• 使用模块 ： multiprocessing
• 创建流程
  ①.将需要新进程执行的事件封装为函数
  ②.通过模块的Process类创建进程对象，关联函数
  ③.可以通过进程对象设置进程信息及属性
  ④.通过进程对象调用start启动进程
  ⑤.通过进程对象调用join回收进程资源

  父进程定义变量，

2.接口的使用

• Process()
  功能 ： 创建进程对象
  参数 ： target 绑定要执行的目标函数
  　　　　rgs 元组，用于给target函数位置传参
  　　　　kwargs 字典，给target函数键值传参
• p.start()
  功能 ： 启动进程

注意:启动进程此时target绑定函数开始执行，该函数作为子进程执行内容，此时进程真正被创建

• p.join([timeout])
  功能：阻塞等待回收进程
  参数：超时时间

注意

使用multiprocessing创建进程同样是子进程复制父进程空间代码段，父子进程运行互不影响。
子进程只运行target绑定的函数部分，其余内容均是父进程执行内容。
multiprocessing中父进程往往只用来创建子进程回收子进程，具体事件由子进程完成。
multiprocessing创建的子进程中无法使用标准输入

Demo【简单使用】

"""
multiprocessing

1	将需要新进程执行的事件封装为函数

2 通过模块的Process类创建进程对象，关联函数

3 通过进程对象调用start启动进程

4 通过进程对象调用join回收进程资源
"""
import multiprocessing as mp
from time import  sleep

a = 1

# 进程函数
def fun():
    global a
    print("开始一个进程")
    sleep(2)
    a = 1000
    print("a = ",a)
    print("进程结束了，实际也没干啥")

if __name__ == '__main__':

    # 创建进程对象
    p = mp.Process(target=fun) # 绑定函数 此时还没有创建进程

    # start启动进程 自动执行fun函数，作为一个进程执行
    p.start()  # 此时进程才产生

    print("原有进程也干点事")
    sleep(3)
    print("原有进程其实也没干啥")

    # 回收进程
    p.join()

    print("a :",a) # a = 1

Demo【参数传递拓展】

"""
包含参数的进程函数
"""
from multiprocessing import Process
from time import sleep

# 带参数的进程
def worker(name,sec):
    for i in range(3):
        sleep(sec)
        print("I'm %s"%name)
        print("I'm working")

if __name__ == '__main__':
    # 创建进程对象
    p = Process(target=worker,args=("ITCASE",2))
    # 方式二
    # p = Process(target=worker,args=("itcase",),kwargs={'sec':2})
    p.start()
    p.join(3)

3.进程对象

p.name 进程名称

p.pid 对应子进程的PID号

p.is_alive() 查看子进程是否在生命周期

p.daemon 设置父子进程的退出关系

如果设置为True则子进程会随父进程的退出而结束
要求必须在start()前设置
如果daemon设置成True 通常就不会使用 join()

python的thread模块是比较底层的模块，python的threading模块是对thread做了一些包装的，可以更加方便的被使用

Demo【生命周期】

from multiprocessing import Process
from time import sleep,ctime
def tm():
   for i in range(3):
     sleep(2)
     print(ctime())
 
 p = Process(target = tm,name = 'Mythread')
 p.daemon = True # 子进程会随父进程退出
 p.start()
 
print("Name:",p.name)  # 名称
print("PID:",p.pid)  # PID
print("Is alive:",p.is_alive()) 

五.进程池实现

1.必要性

①. 进程的创建和销毁过程消耗的资源较多

②.当任务量众多，每个任务在很短时间内完成时，需要频繁的创建和销毁进程。此时对计算机压力较大

③.进程池技术很好的解决了以上问题。

2.原理

创建一定数量的进程来处理事件，事件处理完进 程不退出而是继续处理其他事件，直到所有事件全都处理完毕统一销毁。增加进程的重复利用，降低资源消耗。

3.进程池实现

• ①.创建进程池对象，放入适当的进程

from multiprocessing import Pool

Pool(processes)

功能： 创建进程池对象
参数： 指定进程数量，默认根据系统自动判定

• ②.将事件加入进程池队列执行

pool.apply_async(func,args,kwds)

功能: 使用进程池执行 func事件
参数： func 事件函数
　　args 元组 给func按位置传参
　　kwds 字典 给func按照键值传参
返回值： 返回函数事件对象

• ③.关闭进程池

pool.close()

功能： 关闭进程池

• ④. 回收进程池中进程

pool.join()

功能： 回收进程池中进程

Demo【进程池】

1 from multiprocessing import Pool
 2 from time import sleep,ctime
 3 
 4 # 进程池事件
 5 def worker(msg):
 6   sleep(2)
 7   print(msg)
 8   return ctime()
 9 
10 # 创建进程池
11 pool = Pool(4)
12 
13 # 向进程池添加执行事件
14 for i in range(10):
15   msg = "Hello %d"%i
16 
17   # r 代表func事件的一个对象
18   r = pool.apply_async(func=worker,args=(msg,))
19 
20 # 关闭进程池
21 pool.close()
22 
23 # 回收进程池
24 pool.join()
25 
26 print(r.get()) # 可以获取事件函数的返回值