Python廖雪峰教程学习笔记：Day15

前言

养成一个好的习惯只需要坚持21天，Day15

多进程

Unix/Linux操作系统提供了一个fork()系统调用。一般我们遇到的函数都是调用一次便返回一次，这里的fork()调用一次返回两次。因为操作系统自动把当前进程（称为父进程）复制了一份（称为子进程），然后，分别在父进程和子进程内返回。
子进程永远返回0，而父进程返回子进程的ID。
fork调用，一个进程在接到新任务时就可以复制出一个子进程来处理新任务，常见的Apache服务器就是由父进程监听端口，每当有新的http请求时，就fork出子进程来处理新的http请求。

multiprocessing

当我们编写多进程的服务程序时，由于Windows没有fork调用，就可以使用multiprocessing模块来进行跨平台的多进程操作。

from multiprocessing import Process
import os
#子进程要执行的代码
def run_proc(name):
	print('Run child process %s (%s)...' % (name, os.getpid())) # 调用getppid()就可以拿到父进程的ID。
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.')
# 运行结果：Parent process 928.
# Child process will start.
# Run child process test (929)...
# Process end.

由上面这个简单的实例可知，创建子线程时，只需要传进一个执行函数和函数的参数，如上面例子中的target=run_proc, args=('test',)。注意，函数的参数传入之后，后面还有一个逗号。创建一个Process实例之后，用start()方法启动。join()方法可以等待子进程结束后再继续往下运行，通常用于进程间的同步。

Pool

如果要启动大量的子进程，可以用进程池的方式批量创建子进程：

from multiprocessing import Pool
import os, time, random

def long_time_task(name):
    print('Run task %s (%s)...' % (name, os.getpid()))
    start = time.time()
    time.sleep(random.random() * 3)
    end = time.time()
    print('Task %s runs %0.2f seconds.' % (name, (end - start)))

if __name__=='__main__':
    print('Parent process %s.' % os.getpid())
    p = Pool(4)
    for i in range(5):
        p.apply_async(long_time_task, args=(i,))
    print('Waiting for all subprocesses done...')
    p.close()
    p.join()
    print('All subprocesses done.')

运行结果：

Parent process 1111.
Waiting for all subprocesses done...
Run task 2 (1114)...Run task 0 (1113)...Run task 3 (1115)...
Run task 1 (1112)...
Task 0 runs 0.31 seconds.
Run task 4 (1113)...
Task 1 runs 0.47 seconds.
Task 3 runs 0.77 seconds.
Task 2 runs 1.08 seconds.
Task 4 runs 2.21 seconds.
All subprocesses done.

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

进程间通信

在Python的multiprocessing模块，Process之间的通信可以使用Queue、Pipes等多种方式来交换数据。如下面的例子，我们创建两个子进程，一个往Queue里面写数据，一个从Queue里面读数据。

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，写入:
    pw.start()
    # 启动子进程pr，读取:
    pr.start()
    # 等待pw结束:
    pw.join()
    # pr进程里是死循环，无法等待其结束，只能强行终止:
    pr.terminate()