Python 第六天（进程之间的通信通道：队列和管道、进程之间的共享）

最新推荐文章于 2025-01-16 17:47:01 发布

原创最新推荐文章于 2025-01-16 17:47:01 发布 · 262 阅读

0 ·

CC 4.0 BY-SA版权

本文介绍了Python中进程间通信的三种方式：进程锁、管道和队列。通过示例详细阐述了如何使用Pipe创建双向管道，Queue实现线程安全的共享队列，并探讨了进程间数据共享的方法，包括列表、数组和字典的共享。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

进程锁

进程之间数据不共享，但是共享同一套文件系统，所以访问同一个文件，或同一个打印终端，是没有问题，竞争带来的结果就是错乱，如何控制，就是加锁处理。

# 进程同步
import os
import multiprocessing
import time
# 多进程，并发，可能乱序并发执行（主要看系统如何处理）
# 多进程加锁，挨个执行,也可能是乱序
def showdata(lock, i):
    with lock:
        print(multiprocessing.current_process().name)
        time.sleep(2)
        print(i)
        
if __name__ == "__main__":
    lock = multiprocessing.RLock()  # 创建锁
    for num in range(10):
        multiprocessing.Process(target=showdata, args=(lock, num)).start()

运行结果
在这里插入图片描述

管道

Pipe() 函数返回一个由管道连接的连接对象，默认情况下是双工（双向）。
multiprocessing.Pipe([duplex])，返回一对Connection对象：(conn1, conn2)，分别表示管道的两端。
如果 duplex 被置为 True (默认值)，那么该管道是双向的。如果 duplex 被置为 False ，那么该管道是单向的，即 conn1 只能用于接收消息，而 conn2 仅能用于发送消息。

send(obj)
将一个对象发送到连接的另一端，可以用 recv() 读取。
发送的对象必须是可以序列化的，过大的对象有可能引发 ValueError 异常。
recv()
返回一个由另一端使用 send() 发送的对象。该方法会一直阻塞直到接收到对象。如果对端关闭了连接或者没有东西可接收，将抛出 EOFError 异常。

例子

import multiprocessing

def A(conn):
    while 1:
        print('A',conn.recv())

if __name__ == "__main__":
    conn_a,conn_b = multiprocessing.Pipe()
    p = multiprocessing.Process(target = A,args = (conn_a,))
    p.start()
    while 1:
        input_ = input('>>>')
        conn_b.send(input_)

运行结果

队列

multiprocessing.Queue([maxsize])，返回一个使用一个管道和少量锁和信号量实现的共享队列实例。当一个进程将一个对象放进队列中时，一个写入线程会启动并将对象从缓冲区写入管道中。
注意队列只能单向，要么是父进程插入子进程取出，要么是子进程插入父进程取出

Queue.qsize()
返回队列的大致大小。注意，qsize() > 0 不保证后续的 get() 不被阻塞，qsize() < maxsize 也不保证 put() 不被阻塞。
Queue.empty()
如果队列为空，返回 True ，否则返回 False 。如果 empty() 返回 True ，不保证后续调用的 put() 不被阻塞。类似的，如果 empty() 返回 False ，也不保证后续调用的 get() 不被阻塞。
Queue.full()
如果队列是满的返回 True ，否则返回 False 。如果 full() 返回 True 不保证后续调用的 get() 不被阻塞。类似的，如果 full() 返回 False 也不保证后续调用的 put() 不被阻塞。
Queue.put(item, block=True, timeout=None)
将 item 放入队列。如果可选参数 block 是 true 并且 timeout 是 None (默认)，则在必要时阻塞至有空闲插槽可用。如果 timeout 是个正数，将最多阻塞 timeout 秒，如果在这段时间没有可用的空闲插槽，将引发 Full 异常。反之 (block 是 false)，如果空闲插槽立即可用，则把 item 放入队列，否则引发 Full 异常 ( 在这种情况下，timeout 将被忽略)。
Queue.put_nowait(item)
相当于 put(item, False) 。
Queue.get(block=True, timeout=None)
从队列中移除并返回一个项目。如果可选参数 block 是 true 并且 timeout 是 None (默认值)，则在必要时阻塞至项目可得到。如果 timeout 是个正数，将最多阻塞 timeout 秒，如果在这段时间内项目不能得到，将引发 Empty 异常。反之 (block 是 false) , 如果一个项目立即可得到，则返回一个项目，否则引发 Empty 异常 (这种情况下，timeout 将被忽略)。
Queue.get_nowait()
相当于 get(False) 。
Queue.task_done()
表示前面排队的任务已经被完成。被队列的消费者线程使用。每个 get() 被用于获取一个任务，后续调用 task_done() 告诉队列，该任务的处理已经完成。
如果 join() 当前正在阻塞，在所有条目都被处理后，将解除阻塞(意味着每个 put() 进队列的条目的 task_done() 都被收到)。
如果被调用的次数多于放入队列中的项目数量，将引发 ValueError 异常。
Queue.join()
阻塞至队列中所有的元素都被接收和处理完毕。
当条目添加到队列的时候，未完成任务的计数就会增加。每当消费者线程调用 task_done() 表示这个条目已经被回收，该条目所有工作已经完成，未完成计数就会减少。当未完成计数降到零的时候， join() 阻塞被解除。

例子

import multiprocessing

def M(conn):
    while 1:
        recv_ = conn.recv()
        print("机器人收到：%s"%recv_)
        if recv_ =="你好":
            conn.send('我不好~')
        elif recv_ =="今天天气怎么样":
            conn.send('我不知道~')
        elif recv_ =="我美吗":
            conn.send('美~')
        else:
            conn.send('不要打扰我~')

def P(conn):
    y = 'y'
    while y != 'n':
        input_ = input("人说：")
        conn.send(input_)
        print("机器人说：%s"%(conn.recv()))
    conn.close()

if __name__ =="__main__":
    conn_M,conn_P = multiprocessing.Pipe()
    P_M = multiprocessing.Process(target = M,args = (conn_M,))
    P_M.start()
    P(conn_P)

运行结果

进程之间的共享

进程数据共享

import multiprocessing

def func(num):
    num.value = 10

if __name__ == '__main__':
    # multiprocessing.Value可以在不同进程之间共享数据
    num = multiprocessing.Value('d', 1)  # double float
    print(num.value)  # 单单num返回的结果 Synchronized wrapper for c_double(1.0)
    p = multiprocessing.Process(target=func, args=(num,))
    p.start()
    p.join()
    print(num.value)

运行结果

进程列表数组共享

import multiprocessing

def func(num):
    num[2] = 9999

if __name__ == '__main__':
    # 不同进程之间实现数组共享
    num = multiprocessing.Array('i', [1, 2, 3, 4, 5, 6])  # i代表int类型
    print(num[:])
    p = multiprocessing.Process(target=func, args=(num,))
    p.start()
    p.join()
    print(num[:])

运行结果

进程字典列表共享

import multiprocessing

def func(mydict, mylist):
    mydict["haha"] = "heihei"
    mydict["lala"] = "hehe"
    mylist.append(11)
    mylist.append(22)
    mylist.append(33)

if __name__ == "__main__":
    mydict = multiprocessing.Manager().dict()
    mylist = multiprocessing.Manager().list(range(5))
    p = multiprocessing.Process(target=func, args=(mydict, mylist))
    p.start()
    p.join()
    print(mylist)
    print(mydict)

运行结果