python学习一之多进程

python学习一之多进程

 

概念说明：

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

现在，多核CPU已经非常普及了，但是，即使过去的单核CPU，也可以执行多任务。由于CPU执行代码都是顺序执行的，那么，单核CPU是怎么执行多任务的呢？

答案就是操作系统轮流让各个任务交替执行，任务1执行0.01秒，切换到任务2，任务2执行0.01秒，再切换到任务3，执行0.01秒……这样反复执行下去。表面上看，每个任务都是交替执行的，但是，由于CPU的执行速度实在是太快了，我们感觉就像所有任务都在同时执行一样。

真正的并行执行多任务只能在多核CPU上实现，但是，由于任务数量远远多于CPU的核心数量，所以，操作系统也会自动把很多任务轮流调度到每个核心上执行。

对于操作系统来说，一个任务就是一个进程（Process），比如打开一个浏览器就是启动一个浏览器进程，打开一个记事本就启动了一个记事本进程，打开两个记事本就启动了两个记事本进程，打开一个Word就启动了一个Word进程。

有些进程还不止同时干一件事，比如Word，它可以同时进行打字、拼写检查、打印等事情。在一个进程内部，要同时干多件事，就需要同时运行多个“子任务”，我们把进程内的这些“子任务”称为线程（Thread）。

由于每个进程至少要干一件事，所以，一个进程至少有一个线程。当然，像Word这种复杂的进程可以有多个线程，多个线程可以同时执行，多线程的执行方式和多进程是一样的，也是由操作系统在多个线程之间快速切换，让每个线程都短暂地交替运行，看起来就像同时执行一样。当然，真正地同时执行多线程需要多核CPU才可能实现。

我们前面编写的所有的Python程序，都是执行单任务的进程，也就是只有一个线程。如果我们要同时执行多个任务怎么办？

有两种解决方案：

一种是启动多个进程，每个进程虽然只有一个线程，但多个进程可以一块执行多个任务。

还有一种方法是启动一个进程，在一个进程内启动多个线程，这样，多个线程也可以一块执行多个任务。

当然还有第三种方法，就是启动多个进程，每个进程再启动多个线程，这样同时执行的任务就更多了，当然这种模型更复杂，实际很少采用。

总结一下就是，多任务的实现有3种方式：

• 多进程模式；
• 多线程模式；
• 多进程+多线程模式。

1.安装跨平台多进程模块 multiprocessing

pip install multiprocessing

2.启动一个子进程并等待其结束：

#!/usr/bin/evn python
# _*_ coding: utf-8 _*_
#下面的例子演示了启动一个子进程并等待其结束

from multiprocessing import Process
import os

#子进程要执行的代码
def run_proc(name):
    print('Run child process %s (%s)...' % (name, os.getpid()))

if __name__ == '__main__':
    print('Parent process %s.' % os.getpid())
    p = Process(target=run_proc,args=('test',))
    print('Child process will start.')
    p.start()
    p.join()
    print('Child process end.')

创建子进程时，只需要传入一个执行函数和函数的参数，创建一个Process实例，用start()方法启动，这样创建进程比fork()还要简单。

join()方法可以等待子进程结束后再继续往下运行，通常用于进程间的同步。

3.使用Pool启动大量的子进程，可以用进程池的方式批量创建子进程

对Pool对象调用join()方法会等待所有子进程执行完毕，调用join()之前必须先调用close()，调用close()之后就不能继续添加新的Process了。

请注意输出的结果，task 0，1，2，3是立刻执行的，而task 4要等待前面某个task完成后才执行，这是因为Pool的默认大小在我的电脑上是4，因此，最多同时执行4个进程。这是Pool有意设计的限制，并不是操作系统的限制。如果改成：p = Pool(5) 就可以同时跑5个进程。

由于Pool的默认大小是CPU的核数，如果你不幸拥有8核CPU，你要提交至少9个子进程才能看到上面的等待效果。

#!/usr/bin/evn python
# _*_ coding: utf-8 _*_
#下面的例子演示使用Pool启动多个子进程

from multiprocessing import Pool
import os,time,random

#定义执行任务
def task(values):
    print('开始执行进程%s (%s)' %(values,os.getpid()))
    start_time = time.time()
    time.sleep(random.random() * 10) #random.random()生成0和1之间的随机浮点数float
    end_time = time.time()
    print('进程%s(%s)执行结束 run %0.2f seconds' %(values,os.getpid(),(end_time - start_time)))
if __name__ == '__main__':
    print('父进程pid=(%s)' %os.getpid())
    p = Pool(5) #定义同时执行多少个进程
    for i in range(10):
        p.apply_async(task,args=(i,))
    print('Waiting for all subprocesses done...')
    p.close()   #调用close()之后就不能继续添加新的Process了
    p.join()    #调用join()之前必须先调用close()
    print('All task done.')

4.进程之间肯定是需要通信的，操作系统提供了很多机制来实现进程间的通信。Python的multiprocessing模块包装了底层的机制，提供了Queue、Pipes等多种方式来交换数据。

我们以Queue为例，在父进程中创建两个子进程，一个往Queue里写数据，一个从Queue里读数据：

#!/usr/bin/evn python
# _*_ coding: utf-8 _*_
#下面的例子演示了进程间通信

from multiprocessing import Process,Queue
import os,time,random

#写数据进程执行的代码
def write(q):
    print('Process to write: %s' %os.getpid())
    for value in ['A','B','C']:
        print('Put %s to queue...' %value)
        q.put(value)
        time.sleep(random.random())

#读数据进程执行的代码
def read(q):
    print('Process to read: %s' %os.getpid())
    while True:
        value = q.get(True)
        print('Get %s from queue...' %value)

if __name__ == '__main__':
    #父进程创建Queue,并传给各个进程
    q = Queue()
    pw = Process(target=write,args=(q,))
    pr = Process(target=read,args=(q,))
    #启动子进程，写入
    pw.start()
    #启动子进程，读取
    pr.start()
    #等待pw结束
    pw.join()
    # pr进程里是死循环，无法等待其结束，只能强行终止:
    pr.terminate()

 5.口头总结：

口头描述进程：系统执行一个任务就是一个进程，执行多个任务则是多进程，例如打开网易云音乐，打开记事本，打开浏览器各是一个进程，此操作系统正在多进程的工作

口头面熟线程：一个进程的基础上，这个进程内部可能运行着多个子任务，这就是进程的多线程，一个进程的内部同时干着多个事情，比如Word，它可以同时进行打字、拼写检查、打印等事情。