快速入门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
# 这里获取到buf是memoryview类型的，代表了获取到的内存
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()

最后

以上就是贪玩路人为你收集整理的快速入门multiprocessing的全部内容，希望文章能够帮你解决快速入门multiprocessing所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。