进阶——python——多进程（Process 类）

Process 类

multiprocessing 模块通过创建一个 Process 对象然后调用它的 start() 方法来生成进程，Process 与 threading.Thread API 相同。

multiprocessing.Process(group=None, target=None, name=None, args=(), kwargs={}, *, daemon=None)

进程对象，表示在单独进程中运行的活动。参数说明如下：

• group：仅用于兼容 threading.Thread，应该始终是 None。
  
• target：由 run() 方法调用的可调用对象。
  
• name：进程名。
  
• args：目标调用的参数元组。
  
• kwargs：目标调用的关键字参数字典。
  
• daemon：设置进程是否为守护进程，如果是默认值 None，则该标志将从创建的进程继承。
  

multiprocessing.Process 对象具有如下方法和属性。

• run()：进程具体执行的方法。
  
• start()：启动进程。
  
• join([timeout])：如果可选参数 timeout 是默认值 None，则将阻塞至调用 join() 方法的进程终止；如果 timeout 是一个正数，则最多会阻塞 timeout 秒。
  
• name：进程的名称。
  
• is_alive()：返回进程是否还活着。
  
• daemon：进程的守护标志，是一个布尔值。
  
• pid：返回进程 ID。
  
• exitcode：子进程的退出代码。
  
• authkey：进程的身份验证密钥。
  
• sentinel：系统对象的数字句柄，当进程结束时将变为 ready。
  
• terminate()：终止进程。
  
• kill()：与 terminate() 相同，但在 Unix 上使用 SIGKILL 信号。
  
• close()：关闭 Process 对象，释放与之关联的所有资源。
  

看一个使用多进程的示例。

from multiprocessing import Process
import time, os
def target():
    time.sleep(2)
    print ('子进程ID：', os.getpid())
if __name__=='__main__':
    print ('主进程ID：', os.getpid())
    ps = []
    for i in range(10):
        p = Process(target=target)
        p.start()
        ps.append(p)
    for p in ps:
        p.join()

当进程数量比较多时，我们可以利用进程池方便、高效的对进程进行使用和管理。

multiprocessing.pool.Pool([processes[, initializer[, initargs[, maxtasksperchild[, context]]]]])

进程池对象。参数说明如下：

• processes：工作进程数目，如果 processes 为 None，则使用 os.cpu_count() 返回的值。
  
• initializer：如果 initializer 不为 None，则每个工作进程将会在启动时调用 initializer(*initargs)。
  
• maxtasksperchild：一个工作进程在它退出或被一个新的工作进程代替之前能完成的任务数量，为了释放未使用的资源。
  
• context：用于指定启动的工作进程的上下文。
  

有如下两种方式向进程池提交任务：

• apply(func[, args[, kwds]])：阻塞方式。
  
• apply_async(func[, args[, kwds[, callback[, error_callback]]]])：非阻塞方式。
  

import multiprocessing, time
def target(p):
    print('t')
    time.sleep(2)
    print(p)
if __name__ == "__main__":
    pool = multiprocessing.Pool(processes = 5)
    for i in range(3):
        p = 'p%d'%(i)
        # 阻塞式
        pool.apply(target, (p, ))
        # 非阻塞式
        # pool.apply_async(target, (p, ))
    pool.close()
    pool.join()