Python编程之----多进程

Python编程之----多进程

由于GIL的存在，python中的多线程其实并不是真正的多线程，如果想要充分地使用多核CPU的资源，在python中大部分情况需要使用多进程。multiprocessing包是Python中的多进程管理包。

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

所以，multiprocessing的很大一部份与threading使用同一套API，只不过换到了多进程的情境。

一、创建进程的两种方式

'''方式一：Process类调用'''
from multiprocessing import Process
import time

def f(name):
    time.sleep(1)
    print('hello', name,time.ctime())

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

'''方式二：继承Process类调用'''
from multiprocessing import Process
import time

class MyProcess(Process):
    def __init__(self):
        super(MyProcess, self).__init__()

    def run(self):
        time.sleep(1)
        print ('hello', self.name,time.ctime())


if __name__ == '__main__':
    p_list=[]
    for i in range(3):
        p = MyProcess()
        p.start()
        p_list.append(p)

    for p in p_list:
        p.join()

    print('end')

二、process类

class Process(object):
    def __init__(self, group=None, target=None, name=None, args=(), kwargs={}):
        self.name = ''
        self.daemon = False
        self.authkey = None
        self.exitcode = None
        self.ident = 0
        self.pid = 0
        self.sentinel = None

    def run(self):
        pass

    def start(self):
        pass

    def terminate(self):
        pass

    def join(self, timeout=None):
        pass

    def is_alive(self):
        return False

构造方法：

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()：不管任务是否完成，立即停止工作进程

属性：

　　daemon：和线程的setDeamon功能一样

　　name：进程名字。

　　pid：进程号。

三、进程间通信

1、进程对列Queue

from multiprocessing import Process, Queue

def f(q):
    q.put([42, 2, 'hello'])
    print('subprocess a id:',id(q))


if __name__ == '__main__':
    q = Queue()#创建进程队列对象
    p_list = []
    print('main a id:',id(q))

    for i in range(3):
        p = Process(target=f,args=(q,))
        p_list.append(p)
        p.start()

    print(q.get())
    print(q.get())
    print(q.get())

    for i in p_list:
        i.join()

输出：

main a id: 2989661179800
subprocess a id: 2342855017976
[42, 2, 'hello']
subprocess a id: 2493719873184
[42, 2, 'hello']
subprocess a id: 2581219870536
[42, 2, 'hello']

2、管道(pipe)

实现两个进程之间数据的传递。

from multiprocessing import Process, Pipe
import os

def f(conn):
    conn.send('小鱼是傻逼嘛？')#子进程发
    print(conn.recv(),'in the %s' % os.getpid())#子进程收
    conn.close()

if __name__ == '__main__':

    parent_conn, child_conn = Pipe()
    p = Process(target=f, args=(child_conn,))
    p.start()

    print(parent_conn.recv())#父进程收

    parent_conn.send('Hello')#父进程发
    p.join()

输出：

小鱼是傻逼嘛？
Hello in the 17284

Pipe()返回的两个连接对象代表管道的两端。 每个连接对象都有send()和recv()方法（等等）。 请注意，如果两个进程（或线程）尝试同时读取或写入管道的同一端，管道中的数据可能会损坏。

3、数据共享

Queue和pipe只是实现了数据交互，并没实现数据共享，即一个进程去更改另一个进程的数据。
A manager object returned by Manager() controls a server process which holds Python objects and allows other processes to manipulate them using proxies.
Manager（）返回的管理器对象控制一个服务器进程，该进程保存Python对象并允许其他进程使用代理操作它们。

from multiprocessing import Process, Manager

def f(d, l,n):

    d[n] = n
    d["name"] ="alvin"
    l.append(n)

if __name__ == '__main__':

    with Manager() as manager:

        d = manager.dict()

        l = manager.list(range(5))

        p_list = []

        for i in range(10):
            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)

输出：

{0: 0, 'name': 'alvin', 1: 1, 2: 2, 3: 3, 4: 4, 6: 6, 5: 5, 7: 7, 8: 8, 9: 9}
[0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 6, 5, 7, 8, 9]