pyhton：多进程

一、多进程

1、进程的概念

进程是程序在计算机上的一次执行活动。当你运行一个程序，你就启动了一个进程。显然，程序是死的(静态的)，进程是活的(动态的)。进程可以分为系统进程和用户进程。凡是用于完成操作系统的各种功能的进程就是系统进程，它们就是处于运行状态下的操作系统本身;所有由用户启动的进程都是用户进程。

进程是操作系统进行资源分配的单位。 进程又被细化为线程，也就是一个进程下有多个能独立运行的更小的单位。在同一个时间里，同一个计算机系统中如果允许两个或两个以上的进程处于运行状态，这便是多任务。现代的操作系统几乎都是多任务操作系统，能够同时管理多个进程的运行。 多任务带来的好处是明显的，比如你可以边听mp3边上网，与此同时甚至可以将下载的文档打印出来，而这些任务之间丝毫不会相互干扰。那么这里就涉及到并行的问题，俗话说，一心不能二用，这对计算机也一样，原则上一个CPU只能分配给一个进程，以便运行这个进程。我们通常使用的计算机中只有一个CPU，也就是说只有一颗心，要让它一心多用，同时运行多个进程，就必须使用并发技术。

实现并发技术相当复杂，最容易理解的是“时间片轮转进程调度算法”，它的思想简单介绍如下：在操作系统的管理下，所有正在运行的进程轮流使用CPU，每个进程允许占用CPU的时间非常短(比如10毫秒)，这样用户根本感觉不出来 CPU是在轮流为多个进程服务，就好象所有的进程都在不间断地运行一样。但实际上在任何一个时间内有且仅有一个进程占有CPU。 如果一台计算机有多个CPU，情况就不同了，如果进程数小于CPU数，则不同的进程可以分配给不同的CPU来运行，这样，多个进程就是真正同时运行的，这便是并行。但如果进程数大于CPU数，则仍然需要使用并发技术

• 并行运行：总线程数<= CPU数量

• 并发运行：总线程数> CPU数量

2、进程的状态

• 就绪态：运行的条件都已经慢去，正在等在cpu执行
• 执行态：cpu正在执行其功能
• 等待态：等待某些条件满足，例如一个程序sleep了，此时就处于等待态

二、创建进程

multiprocessing模块就是跨平台版本的多进程模块，提供了一个Process类来代表一个进程对象，这个对象可以理解为是一个独立的进程，可以执行另外的事情。

1、函数创建进程

t = multiprocessing.Process([group [, target [, name [, args [, kwargs]]]]]) # 创建进程对象
t.start() # 启动进程

参数说明：

• target：如果传递了函数的引用，可以任务这个子进程就执行这里的代码
• args：给target指定的函数传递的参数，以元组的方式传递
• kwargs：给target指定的函数传递命名参数
• name：给进程设定一个名字，可以不设定
• group：指定进程组，大多数情况下用不到

实例：

from multiprocessing import Process
import time
def run_proc():
    """子进程要执行的代码"""
    while True:
        print("----2----")
        time.sleep(1)
if __name__=='__main__':
    p = Process(target=run_proc) # 创建进程对象
    p.start() # 启动子进程
    while True:
        print("----1----")
        time.sleep(1)

运行结果：

说明：创建子进程时，只需要传入一个执行函数和函数的参数，创建一个Process实例，用start()方法启动

2、通过继承创建进程类

通过继承Process类，来自定义进程类，实现run方法。实例p通过调用p.start()时自动调用run方法。
如下：

import multiprocessing
import time
import os

class MyProcess(multiprocessing.Process):
    def __init__(self,num):
        super().__init__()
        self.sleep_time = num
    def run(self):
        """重写run方法"""
        for i in range(5):
            print('正在执行的进程号：%s'%os.getpid(),'{%s}'%time.ctime(),i)
            time.sleep(self.sleep_time)

if __name__ == '__main__':
    p1 = MyProcess(1)
    p2 = MyProcess(1)
    p1.start() # 启动进程
    p2.start()
    p1.join()
    p2.join()
    print('正在执行的进程号：%s' % os.getpid(), '{%s}' % time.ctime())

运行结果：

三、进程通信，进程池

1.进程间不同享全局变量

进程不像线程一样可以共享全局变量，创建子进程时，子进程会把父进程的资源拷贝一份自己使用：

from multiprocessing import Process
import os
import time
nums = [11, 22]
def work1():
    """子进程要执行的代码"""
    print("in process1 pid=%d ,nums=%s" % (os.getpid(), nums))
    for i in range(3):
        nums.append(i)
        time.sleep(1)
        print("in process1 pid=%d ,nums=%s" % (os.getpid(), nums))

def work2():
    """子进程要执行的代码"""
    print("in process2 pid=%d ,nums=%s" % (os.getpid(), nums))
if __name__ == '__main__':
    p1 = Process(target=work1)
    p1.start()
    p1.join()
    p2 = Process(target=work2)
    p2.start()
    p2.join()

运行结果：

2、进程通信

操作系统提供了许多机制来实现进程间通信，这里我们使用multiprocessing模块的Queue（队列）实现多进程之间的数据传递。Queue就像我们平时排队一样，先到先出。

import multiprocessing
import time,random

def write(q):
    """向队列中存放数据"""
    for value in ['A','B','C']:
        print('向队列里存入%s' %value)
        q.put(value) # 若是队列为full,就会堵塞
        time.sleep(random.random())
# 读数据进程执行的代码:
def read(q):
	"""从队列中取数据"""
    while True:
        if not q.empty():
            value = q.get(True)
            print('Get %s from queue.' % value)
            time.sleep(random.random())
        else:
            break
if __name__=='__main__':
    # 创建队列
    q = multiprocessing.Queue()
    # 父进程创建Queue，并传给各个子进程：
    pw = multiprocessing.Process(target=write, args=(q,))
    pr = multiprocessing.Process(target=read, args=(q,))
    # 启动子进程pw，写入:
    pw.start()
    # 启动子进程pr，读取:
    pr.start()
    # 等待pw结束:
    pw.join()
    pr.join()
    # pr进程里是死循环，无法等待其结束，只能强行终止:
    print('')
    print('所有数据都写入并且读完')

运行结果：

Queue类的部分方法说明：

• Queue.qsize()：返回当前队列包含的消息数量

• Queue.empty()：如果队列为空，返回True，反之False

• Queue.full()：如果队列满了，返回True,反之False

• Queue.get([block[, timeout]])：获取队列中的一条消息，然后将其从列队中移除，block默认值为True；
  1）如果block使用默认值，且没有设置timeout（单位秒），消息列队如果为空，此时程序将被阻塞（停在读取状态），直到从消息列队读到消息为止，如果设置了timeout，则会等待timeout秒，若还没读取到任何消息，则抛出"Queue.Empty"异常；
  2）如果block值为False，消息列队如果为空，则会立刻抛出"Queue.Empty"异常；

• Queue.get_nowait()：相当Queue.get(False)

• Queue.put(item,[block[, timeout]])：将item消息写入队列，block默认值为True；
  1）如果block使用默认值，且没有设置timeout（单位秒），消息列队如果已经没有空间可写入，此时程序将被阻塞（停在写入状态），直到从消息列队腾出空间为止，如果设置了timeout，则会等待timeout秒，若还没空间，则抛出"Queue.Full"异常；
  2）如果block值为False，消息列队如果没有空间可写入，则会立刻抛出"Queue.Full"异常；

• Queue.put_nowait(item)：相当Queue.put(item, False)；

3、进程池

当需要创建的子进程数量不多时，可以直接利用multiprocessing中的Process动态成生多个进程，但如果是上百甚至上千个目标，手动的去创建进程的工作量巨大，此时就可以用到multiprocessing模块提供的Pool方法。
初始化Pool时，可以指定一个最大进程数，当有新的请求提交到Pool中时，如果池还没有满，那么就会创建一个新的进程用来执行该请求；但如果池中的进程数已经达到指定的最大值，那么该请求就会等待，直到池中有进程结束，才会用之前的进程来执行新的任务。

import multiprocessing
import os, time, random
def worker(msg):
    t_start = time.time()
    print("%s开始执行,进程号为%d" % (msg,os.getpid()))
    # random.random()随机生成0~1之间的浮点数
    time.sleep(random.random()*2)
    t_stop = time.time()
    print(msg,"执行完毕，耗时%0.2f" % (t_stop-t_start))
if __name__ == '__main__':
    po = multiprocessing.Pool(3)  # 定义一个进程池，最大进程数3
    for i in range(0,10):
        # Pool().apply_async(要调用的目标,(传递给目标的参数元祖,))
        # 每次循环将会用空闲出来的子进程去调用目标
        po.apply_async(worker,(i,))
    print("----start----")
    po.close()  # 关闭进程池，关闭后po不再接收新的请求
    po.join()  # 等待po中所有子进程执行完成，必须放在close语句之后
    print("-----end-----")

运行结果：

----start----
0开始执行,进程号为17552
1开始执行,进程号为10652
2开始执行,进程号为3176
2 执行完毕，耗时1.02
3开始执行,进程号为3176
1 执行完毕，耗时1.14
4开始执行,进程号为10652
3 执行完毕，耗时0.18
5开始执行,进程号为3176
0 执行完毕，耗时1.66
6开始执行,进程号为17552
4 执行完毕，耗时0.52
7开始执行,进程号为10652
5 执行完毕，耗时1.33
8开始执行,进程号为3176
6 执行完毕，耗时1.43
9开始执行,进程号为17552
7 执行完毕，耗时1.52
9 执行完毕，耗时0.57
8 执行完毕，耗时1.00
-----end-----

multiprocessing.Pool常用函数解析：

• apply_async(func[, args[, kwds]]) ：使用非阻塞方式调用func（并行执行，堵塞方式必须等待上一个进程退出才能执行下一个进程），args为传递给func的参数列表，kwds为传递给func的关键字参数列表；
• close()：关闭Pool，使其不再接受新的任务；
• terminate()：不管任务是否完成，立即终止；
• join()：主进程阻塞，等待子进程的退出， 必须在close或terminate之后使用；

注意：

进程池中使用进程通信不能使用multiprocessing模块中的Queue类来实现进程间通信，而要使用multiprocessing模块中Manager()的Queue才可以，不然会报错