python multiprocessing


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()
    print(p.pid)#必须在start()方法之后，和上面的进程里面的os.getpid 值一样的
    p.join()
    print('Child process end.')

# 进程池

import multiprocessing
import os
import time
def run_proc(name):
    time.sleep(10)
    print('Run child process %s (%s)...' % (name, os.getpid()))
　　 return name

if __name__=='__main__':
    print('Parent process %s.' % os.getpid())
    pool = multiprocessing.Pool(3)
    plist=[]
    for i in range(10):
        pool.apply_async(run_proc, args=('test' + str(i),))
    pool.close()
    pool.join() #join之前必须close pool


task = pool.apply_async(run_proc, args=('test' + str(5),))
task.get()#the run_proc's return value

进程间的通信可以使用 multiprocessing 提供的queue模块

from multiprocessing import Process, Queue
import time
def produce(q):
    q.put("a")
    time.sleep(2)

def consume(q):
    time.sleep(2)
    data = q.get()
    print(data)

if __name__ == '__main__':
    q = Queue()
    p = Process(target=produce, args=(q,))
    c = Process(target=consume, args=(q,))
    p.start()
    c.start()
    p.join()
    c.join()

multiprocessing 中的 queue 不能用于pool进程池。线程池中通信可以使用Manager 中的 queue

# #进程池中的进程如何通信

进程之前不能共享全局变量，需要有个公共的队列来操作存放信息


# -*- coding: UTF-8 -*-

import os
import multiprocessing
import time


def write(q):
        print("write启动(%s)，父进程为(%s)" % (os.getpid(), os.getppid()))
        for i in "python":
                q.put(i)


def read(q):
        print("read启动(%s)，父进程为(%s)" % (os.getpid(), os.getppid()))
        for i in range(q.qsize()):
                print("read从Queue获取到消息：%s" % q.get(True))


if __name__ == "__main__":
        print("(%s) start" % os.getpid())
        q = multiprocessing.Manager().Queue()
        po = multiprocessing.Pool()
        for i in range(2):
            po.apply_async(write, args=(q,))
        time.sleep(2)
        po.apply_async(read, args=(q,))
        po.close()
        po.join()
        print("(%s) end" % os.getpid())

进程间的通信还可以是用mulriprocessing 提供的Pipe方法。

1 Pipe 方法只适用于两个进程间的通信

2 Pipe的性能是高于queue的(中间要使用锁等)

from multiprocessing import Process, Pipe
import time
def produce(pipe):
    pipe.send("hello")

def consume(pipe):
        print(pipe.recv())

if __name__ == '__main__':
    receive_pipe, send_pipe = Pipe()
    p = Process(target=produce, args=(send_pipe,))
    c = Process(target=consume, args=(receive_pipe,))
    p.start()
    c.start()
    p.join()
    c.join()

进程间使用Manager的Manager() 返回的管理器对象控制一个服务器进程，该进程保存Python对象并允许其他进程使用代理操作它们。
类似于进程间的共享内存变量，但是性能比使用共享内存慢。

Manager()支持dict() list()等等常见的数据类型

from multiprocessing import Process, Manager
import time
def produce(data):
    data["name"] = "zhangsan"

def consume(data):
    time.sleep(2)
    print(data["name"])


if __name__ == '__main__':
    data = Manager().dict()
    p = Process(target=produce, args=(data,))
    c = Process(target=consume, args=(data,))
    p.start()
    c.start()
    p.join()
    c.join()

文档看这里

https://docs.python.org/zh-cn/2/library/multiprocessing.html#module-multiprocessing

https://docs.python.org/zh-cn/3/library/multiprocessing.html

Python的multiprocessing模块不但支持多进程，其中managers子模块还支持把多进程分布到多台机器上。一个服务进程可以作为调度者，将任务分布到其他多个进程中，依靠网络通信。由于managers模块封装很好，不必了解网络通信的细节，就可以很容易地编写分布式多进程程序。

managers 提供了一种创建共享数据的方法，从而可以在不同进程中共享，甚至可以通过网络跨机器共享数据。管理器维护一个用于管理 共享对象 的服务。其他进程可以通过代理访问这些共享对象。

具体可以参考这里

https://www.liaoxuefeng.com/wiki/1016959663602400/1017631559645600#0