进程中的操作

回头科科

已于 2022-04-12 10:42:30 修改

阅读量1k

点赞数

CC 4.0 BY-SA版权

分类专栏：网络以及线程进程协程文章标签： python 队列进程

于 2022-04-10 19:25:40 首次发布

本文链接：https://blog.csdn.net/jcf52/article/details/124081700

网络以及线程进程协程专栏收录该内容

14 篇文章

订阅专栏

本文介绍了Python中的进程间通信，重点讨论了锁、信号量和事件的使用，以及如何通过`multiprocessing.Queue`进行进程间数据交换。通过示例展示了加锁和信号量的区别，以及队列的创建、方法和使用场景，强调了队列在并发编程中处理数据安全和效率的重要性。

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

一.锁

1.1加锁

1.2信号量：一把锁配多把钥匙 from multiprocessing import Semaphore

二.事件 from multiprocessing import Event

三.进程间通信——队列（multiprocessing.Queue）

一.锁

我们实现了程序的异步，让多个任务可以同时在几个进程中并发处理，他们之间的运行没有顺序，一旦开启也不受我们控制。尽管并发编程让我们能更加充分的利用IO资源，但是也给我们带来了新的问题。
当多个进程使用同一份数据资源的时候，就会引发数据安全或顺序混乱问题。

进程锁: 也是为了控制同一操作系统中多个进程访问一个共享资源，只是因为程序的独立性，各个进程是无法控制其他进程对资源的访问的，但是可以使用本地系统的信号量控制（操作系统基本知识）。

os.getpid () Python中的method用于获取当前进程的进程ID

1.1加锁

第一种没有加锁：

import time,os
from multiprocessing import Process,Lock

def fun(lock,n):
    # lock.acquire()
    print("我是子进程：%s 进程🆔id为：%s"%(n,os.getpid()))
    time.sleep(2)
    print("回头科科：%s 进程🆔id为：%s"%(n,os.getpid()))
    # lock.release()

if __name__ == "__main__":
    lock = Lock()
    for i in range(5):
        p = Process(target=fun,args=(lock,i,))
        p.start()
    print("我是主进程")

第二种加锁：

代码：

import time,os
from multiprocessing import Process,Lock

def fun(lock,n):
    lock.acquire()
    print("我是子进程：%s 进程🆔id为：%s"%(n,os.getpid()))
    time.sleep(2)
    print("回头科科：%s 进程🆔id为：%s"%(n,os.getpid()))
    lock.release()

if __name__ == "__main__":
    lock = Lock()
    for i in range(5):
        p = Process(target=fun,args=(lock,i,))
        p.start()
    print("我是主进程")

使用加锁的形式实现了顺序的执行

1.2信号量：一把锁配多把钥匙 from multiprocessing import Semaphore

代码：

from multiprocessing import Semaphore
l = Semaphore(3)
l.acquire()
print(1)
l.acquire()
print(2)
l.acquire()
print(3)
# l.release()
l.acquire()
print(4)
l.release()

from multiprocessing import Semaphore
l = Semaphore(3)
l.acquire()
print(1)
l.acquire()
print(2)
l.acquire()
print(3)
l.release()
print(4)

结果截然不同：

第一种：

第二种：

这就是锁的操作没有解锁就执行不了下面的内容

而信号量的参数代表了几个锁

所以有人肯定会问：

下面这种情况：

from multiprocessing import Semaphore
l = Semaphore(3)
l.acquire()
print(1)
l.acquire()
print(2)
l.acquire()
print(3)
print(4)
l.release()

这样大家仔细看看是不是给两个输出上了锁！！！

二.事件 from multiprocessing import Event

Queue([maxsize]) 
#创建共享的进程队列。
#参数 ：maxsize是队列中允许的最大项数。如果省略此参数，则无大小限制。 
#底层队列使用管道和锁定实现。

from  multiprocessing import Event
e =Event()
print(e.is_set())
e.set()
e.clear()
e.set()
e.wait()
print("jjj")

事件通过is_set()的bool值，去标识e.wait()的阻塞状态
当is_set()的bool值为False时，e.wait()是阻塞状态
当is_set()的bool值为True时，e.wait()是非阻塞状态
当使用set()时，是把is_set的bool值变为True
当使用clear()时，是把is_set的bool值变为 False

加锁可以保证多个进程修改同一块数据时，同一时间只能有一个任务可以进行修改，即串行的修改，没错，速度是慢了，但牺牲了速度却保证了数据安全。
虽然可以用文件共享数据实现进程间通信，但问题是：
1.效率低（共享数据基于文件，而文件是硬盘上的数据）
2.需要自己加锁处理
因此我们最好找寻一种解决方案能够兼顾：
1、效率高（多个进程共享一块内存的数据）
2、帮我们处理好锁问题。这就是mutiprocessing模块为我们提供的基于消息的IPC通信机制：队列和管道。
队列和管道都是将数据存放于内存中
队列又是基于（管道+锁）实现的，可以让我们从复杂的锁问题中解脱出来，
我们应该尽量避免使用共享数据，尽可能使用消息传递和队列，避免处理复杂的同步和锁问题，而且在进程数目增多时，往往可以获得更好的可获展性。

三.进程间通信——队列（multiprocessing.Queue）

特点：数据先进先出（First In First Out）简称 FIFO

创建共享的进程队列，Queue是多进程安全的队列，可以使用Queue实现多进程之间的数据传递。

Queue([maxsize]) 
#创建共享的进程队列。 
#参数 ：maxsize是队列中允许的最大项数。如果省略此参数，则无大小限制。 
#底层队列使用管道和锁定实现。

3.1方法介绍

1.Queue([maxsize])

创建共享的进程队列。maxsize是队列中允许的最大项数。如果省略此参数，则无大小限制。底层队列使用管道和锁定实现。另外，还需要运行支持线程以便队列中的数据传输到底层管道中。

2.Queue的实例q具有以下方法：

1.q.get( [ block [ ,timeout ] ] )

返回q中的一个项目。如果q为空，此方法将阻塞，直到队列中有项目可用为止。block用于控制阻塞行为，默认为True. 如果设置为False，将引发Queue.Empty异常（定义在Queue模块中）。timeout是可选超时时间，用在阻塞模式中。如果在制定的时间间隔内没有项目变为可用，将引发Queue.Empty异常。

2.q.get_nowait( )
同q.get(False)方法。

3.q.put(item [, block [,timeout ] ] )

将item放入队列。如果队列已满，此方法将阻塞至有空间可用为止。block控制阻塞行为，默认为
True。如果设置为False，将引发Queue.Empty异常（定义在Queue库模块中）。timeout指定在阻塞模式中等待可用空间的时间长短。超时后将引发Queue.Full异常。

4.q.qsize()

返回队列中目前项目的正确数量。此函数的结果并不可靠，因为在返回结果和在稍后程序中使用结果之间，队列中可能添加或删除了项目。在某些系统上，此方法可能引发NotImplementedError异常。

5.q.empty()

如果调用此方法时 q为空，返回True。如果其他进程或线程正在往队列中添加项目，结果是不可靠
的。也就是说，在返回和使用结果之间，队列中可能已经加入新的项目。

6.q.full()

如果q已满，返回为True. 由于线程的存在，结果也可能是不可靠的（参考q.empty（）方法）。.

q.get_nowait ():直接使用get (),如果此时队列中没有元素，那么会阻塞等待，使用get_nowait ()后，如果队列中没有元素，那么会报错 q.put_nowait ():直接使用put (),如果此时队列满了，那么会阻塞等待，使用put_nowait ()后，如果队列已经满了，那么会报错

from multiprocessing import Queue
q = Queue(3)
def fun():
    return 1
q.put(fun)
a=q.get(fun)  # 阻塞等待获取数据，如果有数据直接获取，
            # 如果没有数据，阻塞等待
print(a())
q.put(fun())
q.put(fun())
q.put(fun())
print(q.qsize())  #返回队列中目前项目的正确数量
# q.put(fun)      # 阻塞，如果可以继续往队列中放数据
#             # ，就直接放，不能放就阻塞
# q.get_nowait() # 队列满了并且超出不报错

# q.put_nowait(fun) # 不阻塞，如果可以继续往队列
#                 # 中放数据，就直接放，不能放就报错
b= q.get(fun)
print(b)

3.2队列用法

'''
multiprocessing模块支持进程间通信的两种主要形式:管道和队列
都是基于消息传递实现的,但是队列接口
'''
from multiprocessing import Queue
q=Queue(3)
#put ,get ,put_nowait,get_nowait,full,empty
q.put(3)
q.put(3)
q.put(3)
# q.put(3) # 如果队列已经满了，程序就会停在这里，
        # 等待数据被别人取走，再将数据放入队列。 1
        # 如果队列中的数据一直不被取走，程序就会永远停在这里。
try:
    q.put_nowait(3) # 可以使用put_nowait，如果队列满了不会阻塞，
                    # 但是会因为队列满了而报错。
except: # 因此我们可以用一个try语句来处理这个错误。这
            # 样程序不会一直阻塞下去，但是会丢掉这个消息。
        print('队列已经满了')
#        因此，我们再放入数据之前，可以先看一下队列的状态，
        # 如果已经满了，
        # 就不继续put了。
print(q.full()) #满了
print(q.get())
print(q.get())
print(q.get())
# print(q.get()) # 同put方法一样，如果队列已经空了，那么继续取就会出现阻塞。
try:
    q.get_nowait() # 可以使用get_nowait，如果队列满了不会阻塞，但是会因为没取到值而报错。
except: # 因此我们可以用一个try语句来处理这个错误。这样程序不会一直阻塞下去。
    print('队列已经空了')
print(q.empty()) #空了

上面这个例子还没有加入进程通信，只是先来看看队列为我们提供的方法，以及这些方法的使用和现象。

3.3子进程发送数据给父进程

import time
from multiprocessing import Process,Queue

def fun(q):
    # 调用主函数中p进程传递过来的进程参数 put函数为向队列中添加一条数据 
    q.put([time.asctime(),'from SX','hello'])

if __name__ == '__main__':
    q =Queue()      #创建一个Queue对象 
    p = Process(target=fun,args=(q,))#创建一个进程 
    p.start()
    print(q.get())
    p.join()