Python并发复习3 - 多进程模块 multiprocessing

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

---

一 、进程的调用

1.1  函数式调用

 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:
         p.join()
     print('end')

1.2 类调用

from multiprocessing import Process
import time

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

    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类

构造方法：

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

   ----------  一个流水线，各个工人共享主线程流水线产品队列数据

2、 管道pipe

 from multiprocessing import Process, Pipe

 def func(contact):
     contact.send("这是管道测试信息")
     contact.close()

 if __name__ == '__main__':
     a_con, b_con = Pipe()
     p = Process(target=func, args=(a_con,))
     print(b_con.recv())
     b_con.send("管道返回信息")

3、manage

--- Manager是一种较为高级的多进程通信方式，它能支持Python支持的的任何数据结构，适用于多个进程不是源于同一个父进程的情形。

原理是：先启动一个ManagerServer进程，这个进程是阻塞的，它监听一个socket，然后其他进程（ManagerClient）通过socket来连接到ManagerServer，实现通信。

 from multiprocessing import Process, Manager
 from time import sleep

 def thread_a_main(sync_data_pool):  # A 进程主函数，存入100+的数
     for ix in range(100, 105):
         sleep(1)
         sync_data_pool.append(ix)

 def thread_b_main(sync_data_pool):  # B 进程主函数，存入300+的数
     for ix in range(300, 309):
         sleep(0.6)
         sync_data_pool.append(ix)

 def _test_case_000():  # 测试用例
     manager = Manager()  # multiprocessing 中的 Manager 是一个工厂方法，直接获取一个 SyncManager 的实例
     sync_data_pool = manager.list()  # 利用 SyncManager 的实例来创建同步数据池
     Process(target=thread_a_main, args=(sync_data_pool, )).start()  # 创建并启动 A 进程
     Process(target=thread_b_main, args=(sync_data_pool, )).start()  # 创建并启动 B 进程
     for ix in range(6):  # C 进程（主进程）中实时的去查看数据池中的数据
         sleep(1)
         print(sync_data_pool)

 if '__main__' == __name__:
     _test_case_000()

四 、进程同步

 from multiprocessing import Process, Lock

 def f(l, i):

     with l.acquire():
         print('hello world %s'%i)

 if __name__ == '__main__':
     lock = Lock()

     for num in range(10):
         Process(target=f, args=(lock, num)).start()