进程

进程的创建方式

方法创建

from multiprocessing import Process
import os
from time import sleep
def func1(name):
    print("当前进程ID：", os.getpid())
    print("父进程ID：", os.getppid())
    print(f"Process:{name} start")
    sleep(3)
    print(f"Process:{name} end")
if __name__ == "__main__":
    print("当前进程ID：", os.getpid())
    # 创建进程
    p1 = Process(target=func1, args=('p1',))
    p2 = Process(target=func1, args=('p2',))
    p1.start()
    p2.start()
###
当前进程ID： 14528
当前进程ID： 10284
当前进程ID： 13628
父进程ID： 14528
Process:p1 start
父进程ID： 14528
Process:p2 start
Process:p1 end
Process:p2 end
###

类创建

和使用 Thread 类创建子线程的方式非常类似，使用 Process 类创建实例化对象，其本质是调用该类的构造方法创建新进程。Process 类的构造方法格式如下：def __init__(self,group=None,target=None,name=None,args=(),kwargs={})

其中，各个参数的含义为：

group：该参数未进行实现，不需要传参；

target：为新建进程指定执行任务，也就是指定一个函数；

name：为新建进程设置名称；

args：为 target 参数指定的参数传递非关键字参数；

kwargs：为 target 参数指定的参数传递关键字参数。

from multiprocessing import Process
from time import sleep
class MyProcess(Process):
    def __init__(self, name):
        Process.__init__(self)
        self.name = name
    def run(self):
        print(f"Process:{self.name} start")
        sleep(3)
        print(f"Process:{self.name} end")
if __name__ == "__main__":
    # 创建进程
    p1 = MyProcess("p1")
    p2 = MyProcess("p2")
    p1.start()
    p2.start()
###
Process:p2 start
Process:p1 start
Process:p2 end
Process:p1 end
###

Queue 实现进程间通信

前面讲解了使用 Queue 模块中的 Queue 类实现线程间通信，但要实现进程间通信，需要使用 multiprocessing 模块中的 Queue 类。

简单的理解 Queue 实现进程间通信的方式，就是使用了操作系统给开辟的一个队列空间，各个进程可以把数据放到该队列中，当然也可以从队列中把自己需要的信息取走。

from multiprocessing import Process, Queue
from time import sleep
class MyProcess(Process):
    def __init__(self, name, mq):
        Process.__init__(self)
        self.name = name
        self.mq = mq
    def run(self):
        print("Process:{} start".format(self.name))
        print('--------------', self.mq.get(), '-------------')
        self.mq.put(self.name)
        print("Process:{} end".format(self.name))
if __name__ == "__main__":
    mq = Queue()
    mq.put('1')
    mq.put('2')
    mq.put('3')
    p1 = MyProcess("p1", mq)
    p2 = MyProcess("p2", mq)
    p3 = MyProcess("p3", mq)
    p1.start()
    p2.start()
    p3.start()

Pipe 实现进程间通信

Pipe 直译过来的意思是“管”或“管道”，和实际生活中的管（管道）是非常类似的。

Pipe 方法返回（conn1， conn2）代表一个管道的两个端。

import multiprocessing
from time import sleep
def func1(conn1):
    sub_info = "Hello!"
    print(f"进程1--{multiprocessing.current_process().pid}发送数据：{sub_info}")
    sleep(1)
    conn1.send(sub_info)
    print(f"来自进程2:{conn1.recv()}")
    sleep(1)
def func2(conn2):
    sub_info = "你好!"
    print(f"进程2--{multiprocessing.current_process().pid}发送数据：{sub_info}")
    sleep(1)
    conn2.send(sub_info)
    print(f"来自进程1:{conn2.recv()}")
    sleep(1)
if __name__ == '__main__':
    # 创建管道
    conn1, conn2 = multiprocessing.Pipe()
    # 创建子进程
    process1 = multiprocessing.Process(target=func1, args=(conn1,))
    process2 = multiprocessing.Process(target=func2, args=(conn2,))
    # 启动子进程
    process1.start()
    process2.start()
###
进程1--18820发送数据：Hello!
进程2--15232发送数据：你好!
来自进程2:你好!
来自进程1:Hello!
###

Manager 管理器实现进程通信

管理器提供了一种创建共享数据的方法，从而可以在不同进程中共享。

from multiprocessing import Process,current_process
from multiprocessing import Manager
def func(name,m_list,m_dict):
  m_dict['name'] = '嘉美'
  m_list.append('你好')
if __name__ == "__main__":
  with Manager() as mgr:
    m_list = mgr.list()
    m_dict = mgr.dict()
    m_list.append('Hello!!')
    #两个进程不能直接互相使用对象，需要互相传递
    p1 = Process(target=func,args=('p1',m_list,m_dict))
    p1.start()
    p1.join()  #等p1进程结束，主进程继续执行
    print(m_list)
    print(m_dict)
###
['Hello!!', '你好']
{'name': '嘉美'}
###