快速入门multiprocessing

快速入门multiprocessing

先上一个官网链接multiprocessing --- 基于进程的并行 — Python 3.9.9 文档

multiprocessing其实就是Python多进程模块，能够使python真正的调用多核（Python的多线程一直都是假的多线程，感兴趣的自行百度）。

最简示例：

import multiprocessing as mp

def func(a):
    print("Process param : ", a)

if __name__ == '__main__':
    p = mp.Process(target=func, args=(12,))
    p.start()
    p.join()

肉眼可见的，和Thread使用方式非常像。

后面的示例，除非必要，不会给出输出结果，自己敲一遍嘛，懒死你~~~

Queue(), Pipe(), pool线程池

queue和pipe的目的都是一样的，就是想获取到进程处理的结果或是一些信息。

Queue()

最简示例：

import multiprocessing as mp

def func(q, arg):
    print("input : ", arg)
    q.put(arg)
    print("Process done ...")

if __name__ == '__main__':
    q = mp.Queue()
    p = mp.Process(target=func, args=(q, "I'm process"))
    p.start()
    p.join()

    print(q.get())

Pipe()

最简示例：

import multiprocessing as mp

def func_1(conn):
    conn.send("process 1")

def func_2(conn):
    conn.send("process 2")

if __name__ == '__main__':
    parent_conn, child_conn = mp.Pipe()
    p1 = mp.Process(target=func_1, args=(child_conn,))
    p2 = mp.Process(target=func_2, args=(child_conn,))
    p1.start()
    p2.start()
    p1.join()
    p2.join()
    print(parent_conn.recv())
    
>>> process 1

可以看出，pipe通过child发送，parent接受，只能给出最终接收到那一个结果

pool进程池

线程池可以帮我们自动完成进程的创建，并执行完毕，也就是Process()什么什么start()什么的，相当于封装了这样的一套原语。

最简示例：

import multiprocessing as mp

def func(arg):
    print("input : ", arg)
    print("Process done ...")
    return arg

if __name__ == '__main__':
    pool = mp.Pool(processes=2)
    res = pool.map(func, ("process in",))
    print(res)

note:
map这里指向的函数只能有一个参数，如果多了就报错啦。这一部分与Process()函数完全不同，元组有十个元素，就将值传入函数执行十遍函数。

还有apply()，apply_async()之类的函数，自行到官网了解

共享内存 value和array

前面提到了，多进程 *** 作并不能 *** 作全局变量，如果需要进程间通讯(PCI)，那么就需要使用共享内存

最简示例：

import time
import multiprocessing as mp

def func_1(v):
    v.value = 20

if __name__ == '__main__':
    v = mp.Value('i', 10)
    p = mp.Process(target=func_1, args=(v, ))
    p.start()
    p.join()
    time.sleep(0.1)
    print(v.value)

代理服务Manager()

使用代理，将更加灵活的使用共享内存。以为他支持任意的类型和对象，当然也更慢。

import time
import multiprocessing as mp

def func_1(dict, list):
    dict["haha"] = 88
    list.append(20)

if __name__ == '__main__':
    with mp.Manager() as m:
        d = m.dict()
        l = m.list()

        p = mp.Process(target=func_1, args=(d, l))
        p.start()
        p.join()
        time.sleep(0.1)
        print(d)
        print(l)

通过名称创建共享内存

这个标题为什么变红了，因为及其重要，如果需要与一个不是python项目所创建的进程，而是一个另外的项目创建的进程沟通数据，那该如何使用共享内存通讯，也就是这种了

在c++或者c#中，一般封装为filemapmemory之类名称，也就是文件内存映射

最简示例;

创建和写入

import time
from multiprocessing import shared_memory

if __name__ == '__main__':
    # 创建一个共享内存
    shm = shared_memory.SharedMemory(name="haha", create=True, size=256)

    buf = shm.buf
    print("created a shared memory, the size is", shm.size)

    buf[0] = 0xab

    # 这里休眠一分钟，等待另一个进程能够读取
    time.sleep(60)

    shm.close()
    shm.unlink()

读取

from multiprocessing import shared_memory

if __name__ == '__main__':
    # 创建一个共享内存
    shm = shared_memory.SharedMemory(name="haha")

    buf = shm.buf
    print("readed a shared memory, the size is", shm.size)

    print(buf[0])

    shm.close()
    shm.unlink()