进程之间的通信

import time,threading
# 首先线程之间是共享内存地址的
def info(que):

    que.put(1)

if __name__ == "__main__":

    q = queue.Queue() #创建一个线程队列queue

    t = threading.Thread(target=info,args=(q,)) 

    t.start()

    print(q.get())

所以取值成成功

image.png

# 现在,我们把线程队列改进程队列
from multiprocessing import Process,Queue
import threading

def info(que):

    que.put(1)

if __name__ == "__main__":

    q = Queue() # 创建一个进程队列

    t = threading.Thread(target=info,args=(q,)) #创建一个线程实例

    t.start()

    print(q.get())
咦。这样好像我们也访问成功了。但是不对啊。我们明明创建的是进程队列啊

是的,但实际上是我们创建的线程实例,线程共享内存地址,所以我们也访问成功

image.png

接下来,我们把线程实例换成进程实例,队列换成线程队列

from multiprocessing import Process,Queue

import queue

def info(que):

    que.put(1)

if __name__ == "__main__":

    q = queue.Queue() # 创建一个线程队列

    t = Process(target=info,args=(q,)) #创建一个线程实例

    t.start()

    print(q.get())

image.png

咦,怎么报错了呢。因为进程是独立空间的,在父进程创建一个线程队列把它传给子进程。进程之间无法相互访问

那怎么解决这个问题呢

from multiprocessing import Process,Queue
import queue

def info(que):
    que.put(1)

if __name__ == "__main__":
    q = Queue() # 创建一个进程队列
    t = Process(target=info,args=(q,)) #创建一个进程实例
    t.start()
    print(q.get())
咦。好像访问成功了。为什么呢？
因为进程队列Queue作为参数传子进程,实际上是克隆了一份队列内存地址传给了子进程,通过内存地址操作,将数据储存在一个中间地址,并进行pickle序列化。

而父进程想要访问子进程传入的数据,就必须去访问中间地址,并进行pickle反序列化。这样就完成了进程之间的通信

image.png

manager(进程数据共享)

from multiprocessing import Process,Manager

import os

def r(d,l):

    d[os.getpid()] = os.getpid()

    l.append(os.getpid())

    print(l)

if __name__ == "__main__":

    manager = Manager()

    dic = manager.dict() # 定义一个可以进程之间共享数据的字典

    lis = manager.list()

    process_list = []

    for i in range(5):
        p = Process(target=r,args=(dic,lis))
        process_list.append(p)
        p.start()
    for i in process_list:
        i.join()
    print(dic)
    print(lis)