day31 进程的创建和通信教程

前情提要：

由于GIL的存在，python中的多线程其实并不是真正的多线程，如果想要充分地使用多核CPU的资源，在python中大部分情况需要使用多进程。Python提供了非常好用的多进程包multiprocessing，只需要定义一个函数，Python会完成其他所有事情。借助这个包，可以轻松完成从单进程到并发执行的转换。multiprocessing支持子进程、通信和共享数据、执行不同形式的同步，提供了Process、Queue、Pipe、Lock等组件。

multiprocessing包是Python中的多进程管理包。与threading.Thread类似，它可以利用multiprocessing.Process对象来创建一个进程。该进程可以运行在Python程序内部编写的函数。该Process对象与Thread对象的用法相同，也有start(), run(), join()的方法。此外multiprocessing包中也有Lock/Event/Semaphore/Condition类 (这些对象可以像多线程那样，通过参数传递给各个进程)，用以同步进程，其用法与threading包中的同名类一致。所以，multiprocessing的很大一部份与threading使用同一套API，只不过换到了多进程的情境。

但在使用这些共享API的时候，我们要注意以下几点:

• 在UNIX平台上，当某个进程终结之后，该进程需要被其父进程调用wait，否则进程成为僵尸进程(Zombie)。所以，有必要对每个Process对象调用join()方法 (实际上等同于wait)。对于多线程来说，由于只有一个进程，所以不存在此必要性。
• multiprocessing提供了threading包中没有的IPC(比如Pipe和Queue)，效率上更高。应优先考虑Pipe和Queue，避免使用Lock/Event/Semaphore/Condition等同步方式 (因为它们占据的不是用户进程的资源)。
• Process.PID中保存有PID，如果进程还没有start()，则PID为None。
• window系统下，需要注意的是要想启动一个子进程，必须加上那句if \_\_name\_\_ == "main"，进程相关的要写在这句下面。

Unix/Linux操作系统下：

Unix/Linux操作系统提供了一个fork()系统调用，它非常特殊。普通的函数调用，调用一次，返回一次，但是fork()调用一次，返回两次，因为操作系统自动把当前进程（称为父进程）复制了一份（称为子进程），然后，分别在父进程和子进程内返回。

子进程永远返回0，而父进程返回子进程的ID。这样做的理由是，一个父进程可以fork出很多子进程，所以，父进程要记下每个子进程的ID，而子进程只需要调用getppid()就可以拿到父进程的ID。

Python的os模块封装了常见的系统调用，其中就包括fork，可以在Python程序中轻松创建子进程：

由于Windows没有fork调用，所以fork调用并不能在Windows系统下实现。而Mac系统是基于BSD（Unix的一种）内核，所以，在Mac下运行是没有问题的。

有了fork调用，一个进程在接到新任务时就可以复制出一个子进程来处理新任务，常见的Apache服务器就是由父进程监听端口，每当有新的http请求时，就fork出子进程来处理新的http请求。

Windows系统下：

如果你打算编写多进程的服务程序，Unix/Linux无疑是正确的选择。Windows系统下虽然没有fork调用，但可以使用multiprocessing模块来实现多进程。

multiprocessing模块提供了一个Process类来代表一个进程对象，下面的例子演示了启动一个子进程并等待其结束：

<pre class="has">

from multiprocessing import Process
def f(name):

print('hello',name)

if name == '__main__':

p_list=[]
for i in range(3):
    p = Process(target=f, args=('AAA',))
    p_list.append(p)
    p.start()
for i in p_list:
    p.join()
print('结束')

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

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

  
  
  
  
  
**构造方法：**

  
  
  
  
  
Process(\[group \[, target \[, name \[, args \[, kwargs\]\]\]\]\])

  
  
  
  
  
 group: 线程组，目前还没有实现，库引用中提示必须是None；   
 target: 要执行的方法；   
 name: 进程名；   
 args/kwargs: 要传入方法的参数。

  
  
  
  
  
**实例方法：**

  
  
  
  
  
 is\_alive()：返回进程是否在运行。

  
  
  
  
  
 join(\[timeout\])：阻塞当前上下文环境的进程程，直到调用此方法的进程终止或到达指定的timeout（可选参数）。

  
  
  
  
  
 start()：进程准备就绪，等待CPU调度

  
  
  
  
  
 run()：strat()调用run方法，如果实例进程时未制定传入target，这star执行t默认run()方法。

  
  
  
  
  
 terminate()：不管任务是否完成，立即停止工作进程

  
  
  
  
  
**属性：**

  
  
  
  
  
 authkey

  
  
  
  
  
 daemon：和线程的setDeamon功能一样

  
  
  
  
  
 exitcode(进程在运行时为None、如果为–N，表示被信号N结束）

  
  
  
  
  
 name：进程名字。

  
  
  
  
  
 pid：进程号。

  
  
  
  
  
  
###  进程间通讯 

  
  
  
  
  
不同进程间内存是不共享的，要想实现两个进程间的数据交换，可以用以下方法：

  
  
  
  
  
**Queues**

  
  
  
  
  
使用方法跟threading里的queue类似：

  
  
  
  
  

```python
from multiprocessing import Process, Queue
def f(q,n):
    q.put([n,'hello'])

if __name__ == '__main__':
    q = Queue()
    p_list=[]
    for i in range(3):
        p = Process(target=f, args=(q,i))
        p_list.append(p)
        p.start()
    print(q.get())
    print(q.get())
    print(q.get())
    for i in p_list:
        i.join()
```

  
  
  
**Pipes**

  
  
  
  
  
Pipe（）函数返回一对通过管道连接的连接对象，管道默认情况下为双工（双向）。 例如：

  
  
  
  
  
```
```python
from multiprocessing import Process, Pipe
def f(conn):
    conn.send([42,None,'hello'])
    conn.close()

if __name__ == '__main__':
    parent_conn, child_conn = Pipe()
    p = Process(target=f, args=(child_conn,))
    p.start()
    print(parent_conn.recv())
```

  
  
  
Pipe（）返回的两个连接对象代表管道的两端。 每个连接对象都有send（）和recv（）方法（以及其他方法）。 请注意，如果两个进程（或线程）试图同时从管道的同一端读取或写入管道的同一端，则管道中的数据可能会损坏。 当然，不存在同时使用管道不同端的过程造成损坏的风险。

  
  
  
  
  
  
  
  
  
  
**Managers**

  
  
  
  
  
由Manager（）返回的管理器对象控制着一个服务器进程，该进程持有Python对象，并允许其他进程使用代理对其进行操作。

  
  
  
  
  
由Manager（）返回的管理器将支持类型列表，字典，命名空间，锁，RLock，信号量，BoundedSemaphore，条件，事件，屏障，队列，值和数组。 例如，

  
  
  
  
  
```
```python
from multiprocessing import Process, Manager
def f(d, l,n):
    d[n] = '1'
    d['2'] = 2
    d[0.25] = None
    l.append(n)
    print(l)

if __name__ == '__main__':
    with Manager() as manager:
        d = manager.dict() #通过他来创建一个字典
        l = manager.list(range(5)) #通过他来创建一个列表
        p_list = []
        for i in range(5):
            p = Process(target=f, args=(d,l,i))
            p.start()
            p_list.append(p)
        for res in p_list:
            res.join()
        print(d)
        print(l)
```