Python多进程

1 进程创建

       python 可以使用fork()语句创建多进程(PS:进程是一个正在运行的程序)、使用multiprocess中的Process 模块进行创建子进程 以及 使用进程池。

方式一:

• 使用fork()语句

import time
import os
print(os.getpid())    # 此处只有一个主进程，使用getpid()函数显示当前进程的id号

ret = os.fork()		# 使用fork()语句创建了一个子进程，子进程永远返回0，而父进程返回子进程的ID，注意，此处开始有两个进程，分别**独立**执行fork()语句下面的代码，进程之间的数据互不影响
if ret == 0:
  print("ret is {} pid is {}  and ppid is {}".format(ret, os.getpid(), os.getppid()))
  while True:
    print("0")
    time.sleep(1)
else:
  print("ret is {} pid is {} ".format(ret, os.getpid()))
  while True:
    print("1")
    time.sleep(1)

运行结果

方式二

• 使用mutiprocessing 中的 Process 类
  • 先定义一个函数，然后在初始化Process实例的时候传递要被执行的函数名，以及函数需要的参数作为实例的参数，然后使用实例名.start()方法执行。

from multiprocessing import Process
import os

# 子进程要执行的代码
def run_proc(name):
    print('Run child process %s (%s)...' % (name, os.getpid()))

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.
Process will start.
Run child process test (929)...
Process end.

- 直接定义一个子类继承Process类，然后再哎子类中重写run()方法，最后实例化子类，并且使用实例化子类，然后使用子类实例化.start()方法即可。

from multiprocess import Process
import time

class DemoProcess(Process):
  def __init__(self, intervel, data):
    Process.__init__(self)
    self.intervel = intervel
    self.data = data
  
  def run(self):
    print("From child Process")
    time.sleep(self.intervel)
    print("sorting is begging!")
    print(sorted(self.data))
    print("sorting is ended!")

if __name__ == "__main__":
  dataList = [2, 5, 9, 4, 1]
  dp = DemoProcess(3, dataList)
  dp.start()
  print("this is 主进程")
  time.sleep(5)
  print("this is parent process2")

运行结果

注意：使用Process创建的子进程会在子进程运行的代码结束后终止，而此时主程序依旧在云从其他的代码，互补影响，如果想让子程序运行完，主程序再运行，可以使用 "实例.join()"进行阻塞其它进行执行。

进程池

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

注意：在使用进程池的时候，需要使用"join()"等待进程池结束后 主进程才结束任务，如下所示：

示例：当没有加 join() 函数，进程池还没有运行完，但是主进程结束之后立即结束进行。

示例：当加入"join()" , 进程池的任务还没有结束，但是主进程运行的代码结束之后还在等待进程池的执行才结束。

总结：
对po对象调用join()方法会等待所有子进程执行完毕，调用join()之前必须先调用close()，调用close()之后就不能继续添加新的Process了。

2进程通信

进程之间的通信分为两种，一种是使用进程池Pool创建的进程之间进行通信，一种是使用Process类实例化出的对用使用Queue队列通信

• （1）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()

运行结果：

• （2）进程池之间的进程使用Manager，例子如下：
• 
  运行结果：