python 进程池与队列结合_python 队列,进程中的队列,管道,数据共享,进程池部分

最新推荐文章于 2023-06-27 22:42:15 发布

weixin_39736150

最新推荐文章于 2023-06-27 22:42:15 发布

阅读量240

点赞数

文章标签： python 进程池与队列结合

进程之间的通信:

队列重要

管道队列的底层

进程之间的数据共享

进程池

进程间的通信: IPC

队列:先进先出FIFO - 维护秩序的时候用的较多买票秒杀

from queue import Queue

q = Queue(5)

print(q.qsize())

q.put(12)

# q.put(3)

# q.put(4)

q.put_nowwait()#当队列满的时候添加会报错,需要使用try

print('***',q.qsize())

print(q.get())

# print(q.get())

# print(q.get()) #没有值的时候会阻塞

print(q.get_nowwait())#当有值的时候取值

print(q.get_nowait())#当没有值的时候会报错

print(q.full())#查看队列是否满了,常和not使用做判断,要使用try

print(q.empty())#查看队列是否是空,常和not使用做判断

print(q.qsize()) #查看队列有几个元素

print(q.get())

print(q.qsize())

栈: 先进后出 -- 算法

三级菜单

计算文件的大小

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

Queue([maxsize])

创建共享的进程队列。

参数：maxsize是队列中允许的最大项数。如果省略此参数，则无大小限制。

底层队列使用管道和锁定实现。

Queue([maxsize])

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

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

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

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

q.get_nowait( )

同q.get(False)方法。

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

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

q.qsize()

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

q.empty()

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

q.full()

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

方法介绍

Queue([maxsize])

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

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

q.get_nowait( )

同q.get(False)方法。

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

q.qsize()

q.empty()

q.full()

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

q.close()

关闭队列，防止队列中加入更多数据。调用此方法时，后台线程将继续写入那些已入队列但尚未写入的数据，但将在此方法完成时马上关闭。如果q被垃圾收集，将自动调用此方法。关闭队列不会在队列使用者中生成任何类型的数据结束信号或异常。例如，如果某个使用者正被阻塞在get()操作上，关闭生产者中的队列不会导致get()方法返回错误。

q.cancel_join_thread()

不会再进程退出时自动连接后台线程。这可以防止join_thread()方法阻塞。

q.join_thread()

连接队列的后台线程。此方法用于在调用q.close()方法后，等待所有队列项被消耗。默认情况下，此方法由不是q的原始创建者的所有进程调用。调用q.cancel_join_thread()方法可以禁止这种行为。

其他方法(了解)

q.close()

q.cancel_join_thread()

不会再进程退出时自动连接后台线程。这可以防止join_thread()方法阻塞。

q.join_thread()

上代码:

'''

multiprocessing模块支持进程间通信的两种主要形式:管道和队列

都是基于消息传递实现的,但是队列接口

'''

from multiprocessing import Queue

q=Queue(3)

#put ,get ,put_nowait,get_nowait,full,empty

q.put(3)

# q.put(3) # 如果队列已经满了，程序就会停在这里，等待数据被别人取走，再将数据放入队列。

# 如果队列中的数据一直不被取走，程序就会永远停在这里。

try:

q.put_nowait(3) # 可以使用put_nowait，如果队列满了不会阻塞，但是会因为队列满了而报错。

except: # 因此我们可以用一个try语句来处理这个错误。这样程序不会一直阻塞下去，但是会丢掉这个消息。

print('队列已经满了')

# 因此，我们再放入数据之前，可以先看一下队列的状态，如果已经满了，就不继续put了。

print(q.full()) #满了

print(q.get())

# print(q.get()) # 同put方法一样，如果队列已经空了，那么继续取就会出现阻塞。

try:

q.get_nowait(3) # 可以使用get_nowait，如果队列满了不会阻塞，但是会因为没取到值而报错。

except: # 因此我们可以用一个try语句来处理这个错误。这样程序不会一直阻塞下去。

print('队列已经空了')

print(q.empty()) #空了

单看队列用法

import time

from multiprocessing import Process, Queue

def f(q):

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

if __name__ == '__main__':

q = Queue() #创建一个Queue对象

p = Process(target=f, args=(q,)) #创建一个进程

p.start()

print(q.get())

p.join()

子进程发送数据给父进程

import os

import time

import multiprocessing

# 向queue中输入数据的函数

def inputQ(queue):

info = str(os.getpid()) + '(put):' + str(time.asctime())

queue.put(info)

# 向queue中输出数据的函数

def outputQ(queue):

info = queue.get()

print ('%s%s\033[32m%s\033[0m'%(str(os.getpid()), '(get):',info))

# Main

if __name__ == '__main__':

multiprocessing.freeze_support()

record1 = [] # store input processes

record2 = [] # store output processes

queue = multiprocessing.Queue(3)

# 输入进程

for i in range(10):

process = multiprocessing.Process(target=inputQ,args=(queue,))

process.start()

record1.append(process)

# 输出进程

for i in range(10):

process = multiprocessing.Process(target=outputQ,args=(queue,))

process.start()

record2.append(process)

for p in record1:

p.join()

for p in record2:

p.join()

批量生产数据放入队列再批量获取结果 x

子进程放另一个子进程取

from multiprocessing import Queue,Process

# def con(q):

# print(q.get())

# def pro(q):

# q.put(123)

# if __name__ == '__main__':

# q = Queue()

# p = Process(target=con,args=(q,))

# p.start()

# p = Process(target=pro, args=(q,))

# p.start()

生产者消费者模型

解决创造(生产)数据和处理(消费)数据的效率不平衡问题

把创造数据和处理数据放在不同的进程中

根据他们的效率来调整进程的个数

生产数据快消费数据慢内存空间的浪费

消费数据快生产数据慢效率低下

import time

import random

from multiprocessing import Process,Queue

def consumer(q,name):

while True:

food = q.get()

if food == 'stop':break

print('%s 吃了 %s'%(name,food))

time.sleep(random.random())

def producer(q,name,food,n=10):

for i in range(n):

time.sleep(random.random())

fd = food+str(i)

print('%s 生产了 %s'%(name,fd))

q.put(fd)

if __name__ == '__main__':

q = Queue(10)

c1 = Process(target=consumer,args=(q,'alex'))

c1.start()

c2 = Process(target=consumer, args=(q, 'alex'))

c2.start()

p1 = Process(target=producer,args=(q,'太白','泔水'))

p1.start()

p2 = Process(target=producer, args=(q, 'egon', '鱼刺'))

p2.start()

p1.join()

p2.join()

q.put('stop')

# 让consumer停下来的方法

# 在所有生产者结束生产之后向队列中放入一个结束符

# 有几个consumer就向队列中放几个结束符

# 在消费者消费的过程中,接收到结束符,就结束消费的进程

import time

import random

from multiprocessing import JoinableQueue,Process

# join 阻塞

def consumer(q,name):

while True:

food = q.get()

print('%s 吃了 %s'%(name,food))

time.sleep(random.random())

q.task_done()

def producer(q,name,food,n=10):

for i in range(n):

time.sleep(random.random())

fd = food+str(i)

print('%s 生产了 %s'%(name,fd))

q.put(fd)

q.join()

if __name__ == '__main__':

q = JoinableQueue()

c1 = Process(target=consumer,args=(q,'alex'))

c1.daemon = True

c1.start()

c2 = Process(target=consumer, args=(q, 'alex'))

c2.daemon = True

c2.start()

p1 = Process(target=producer,args=(q,'太白','泔水'))

p1.start()

p2 = Process(target=producer, args=(q, 'egon', '鱼刺'))

p2.start()

p1.join()

p2.join()

让consumer停下来的方法:

在所有生产者结束生产之后,向队列放入一个结束符

有几个consumer就向队列中放几个结束符

在消费者消费的过程中,接收到结束符,就结束消费的进程

import time

import random

from multiprocessing import JoinableQueue,Process

# join 阻塞

def consumer(q,name):

while True:

food = q.get()

print('%s 吃了 %s'%(name,food))

time.sleep(random.random())

q.task_done()

def producer(q,name,food,n=10):

for i in range(n):

time.sleep(random.random())

fd = food+str(i)

print('%s 生产了 %s'%(name,fd))

q.put(fd)

q.join()

if __name__ == '__main__':

q = JoinableQueue()

c1 = Process(target=consumer,args=(q,'alex'))

c1.daemon = True

c1.start()

c2 = Process(target=consumer, args=(q, 'alex'))

c2.daemon = True

c2.start()

p1 = Process(target=producer,args=(q,'太白','泔水'))

p1.start()

p2 = Process(target=producer, args=(q, 'egon', '鱼刺'))

p2.start()

p1.join()

p2.join()

在并发编程中使用生产者和消费者模式能够解决绝大多数并发问题。该模式通过平衡生产线程和消费线程的工作能力来提高程序的整体处理数据的速度。

为什么要使用生产者和消费者模式

在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。在多线程开发当中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者的处理能力大于生产者，那么消费者就必须等待生产者。为了解决这个问题于是引入了生产者和消费者模式。

什么是生产者消费者模式

生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。

基于队列实现生产者消费者模型

只有multiprocessing中的队列才能帮助你实现 IPC

永远不可能出现数据不安全的情况,多个进程不会同时取走同一个数据

提供给你的方法:

put

get

put_nowait

get_nowait

empty - 在多进程内不可靠

full　　- 在多进程内不可靠

qusize - 在多进程内不可靠

由于先进先出的特点+进程通信的功能+数据进程安全,经常用它来完成进程之间的通信

生产者消费者模型

生产者和消费者的效率不平衡的问题

内存的控制 - 队列的长度限制

让消费者自动停下来

JoinableQueue

在消费数据的时候 task_done

在生产端\主进程 join

管道

# 队列就是基于管道实现的

# 队列数据安全的

# 管道数据不安全的

# 队列 = 管道 + 锁

#创建管道的类：

Pipe([duplex]):在进程之间创建一条管道，并返回元组(conn1,conn2),其中conn1，conn2表示管道两端的连接对象，强调一点：必须在产生Process对象之前产生管道

#参数介绍：

dumplex:默认管道是全双工的，如果将duplex射成False，conn1只能用于接收，conn2只能用于发送。

#主要方法：

conn1.recv():接收conn2.send(obj)发送的对象。如果没有消息可接收，recv方法会一直阻塞。如果连接的另外一端已经关闭，那么recv方法会抛出EOFError。

conn1.send(obj):通过连接发送对象。obj是与序列化兼容的任意对象

#其他方法：

conn1.close():关闭连接。如果conn1被垃圾回收，将自动调用此方法

conn1.fileno():返回连接使用的整数文件描述符

conn1.poll([timeout]):如果连接上的数据可用，返回True。timeout指定等待的最长时限。如果省略此参数，方法将立即返回结果。如果将timeout射成None，操作将无限期地等待数据到达。

conn1.recv_bytes([maxlength]):接收c.send_bytes()方法发送的一条完整的字节消息。maxlength指定要接收的最大字节数。如果进入的消息，超过了这个最大值，将引发IOError异常，并且在连接上无法进行进一步读取。如果连接的另外一端已经关闭，再也不存在任何数据，将引发EOFError异常。

conn.send_bytes(buffer [, offset [, size]])：通过连接发送字节数据缓冲区，buffer是支持缓冲区接口的任意对象，offset是缓冲区中的字节偏移量，而size是要发送字节数。结果数据以单条消息的形式发出，然后调用c.recv_bytes()函数进行接收

conn1.recv_bytes_into(buffer [, offset]):接收一条完整的字节消息，并把它保存在buffer对象中，该对象支持可写入的缓冲区接口(即bytearray对象或类似的对象)。offset指定缓冲区中放置消息处的字节位移。返回值是收到的字节数。如果消息长度大于可用的缓冲区空间，将引发BufferTooShort异常。

介绍

from multiprocessing import Process, Pipe

def f(conn):

conn.send("Hello The_Third_Wave")

conn.close()

if __name__ == '__main__':

parent_conn, child_conn = Pipe()

p = Process(target=f, args=(child_conn,))

p.start()

print(parent_conn.recv())

p.join()

pipe初使用

应该特别注意管道端点的正确管理问题。如果是生产者或消费者中都没有使用管道的某个端点，就应将它关闭。这也说明了为何在生产者中关闭了管道的输出端，在消费者中关闭管道的输入端。如果忘记执行这些步骤，程序可能在消费者中的recv()操作上挂起。管道是由操作系统进行引用计数的，必须在所有进程中关闭管道后才能生成EOFError异常。因此，在生产者中关闭管道不会有任何效果，除非消费者也关闭了相同的管道端点。

from multiprocessing import Pipe

# left,right = Pipe()

# left.send('aaa')

# print(right.recv())

# from multiprocessing import Pipe,Process

# def consumer(left,right):

# left.close()

# while True:

# try:

# print(right.recv())

# except EOFError:

# break

# if __name__ == '__main__':

# left,right = Pipe()

# p = Process(target=consumer,args=(left,right))

# p.start()

# right.close()

# for i in range(10):

# left.send('hello')

# left.close()

EOF异常的触发

# 在这一个进程中如果不在用这个端点了,应该close

# 这一在recv的时候,如果其他端点都被关闭了,就能够知道不会在有新的消息传进来

# 此时就不会在这里阻塞等待,而是抛出一个EOFError

# * close并不是关闭了整个管道,而是修改了操作系统对管道端点的引用计数的处理

# from multiprocessing import Process,Pipe

# def consumer(p,name):

# produce, consume=p

# produce.close()

# while True:

# try:

# baozi=consume.recv()

# print('%s 收到包子:%s' %(name,baozi))

# except EOFError:

# break

# def producer(p,seq=10):

# produce, consume=p

# consume.close()

# for i in range(seq):

# produce.send(i)

# if __name__ == '__main__':

# produce,consume=Pipe()

# for i in range(5):

# c=Process(target=consumer,args=((produce,consume),'c1'))

# c.start()

# for i in range(5):

# p = Process(target=producer, args=((produce, consume)))

# p.start()

# producer((produce,consume))

# produce.close()

# consume.close()

进程之间的数据共享(现在有牛掰的,这个数据安全是问题)

展望未来，基于消息传递的并发编程是大势所趋

即便是使用线程，推荐做法也是将程序设计为大量独立的线程集合，通过消息队列交换数据。

这样极大地减少了对使用锁定和其他同步手段的需求，还可以扩展到分布式系统中。

但进程间应该尽量避免通信，即便需要通信，也应该选择进程安全的工具来避免加锁带来的问题。

以后我们会尝试使用数据库来解决现在进程之间的数据共享问题。

进程间数据是独立的，可以借助于队列或管道实现通信，二者都是基于消息传递的

虽然进程间数据独立，但可以通过Manager实现数据共享，事实上Manager的功能远不止于此

A manager object returned by Manager() controls a server process which holds Python objects and allows other processes to manipulate them using proxies.

A manager returned by Manager() will support types list, dict, Namespace, Lock, RLock, Semaphore, BoundedSemaphore, Condition, Event, Barrier, Queue, Value and Array.

Manager模块介绍

from multiprocessing import Manager,Process,Lock

def work(d,lock):

with lock:

d['count']-=1

if __name__ == '__main__':

lock = Lock()

m = Manager()

dic=m.dict({'count':100})

p_l=[]

for i in range(100):

p=Process(target=work,args=(dic,lock))

p_l.append(p)

p.start()

for p in p_l:

p.join()

print(dic)

# with as 的机制

# __enter__

# __exit__

进程池和multiprocessing.Pool模块

进程池

注意情况:什么情况下使用进程池

开启进程慢

几个cpu就能同时运行几个进程进程的个数不是无限开启的

100个任务

进程池

如果必须用多个进程

且是高计算机型没有IO 型的程序

希望并行最充分的使用CPU

为什么要有进程池?进程池的概念。

在程序实际处理问题过程中，忙时会有成千上万的任务需要被执行，闲时可能只有零星任务。那么在成千上万个任务需要被执行的时候，我们就需要去创建成千上万个进程么？首先，创建进程需要消耗时间，销毁进程也需要消耗时间。第二即便开启了成千上万的进程，操作系统也不能让他们同时执行，这样反而会影响程序的效率。因此我们不能无限制的根据任务开启或者结束进程。那么我们要怎么做呢？

在这里，要给大家介绍一个进程池的概念，定义一个池子，在里面放上固定数量的进程，有需求来了，就拿一个池中的进程来处理任务，等到处理完毕，进程并不关闭，而是将进程再放回进程池中继续等待任务。如果有很多任务需要执行，池中的进程数量不够，任务就要等待之前的进程执行任务完毕归来，拿到空闲进程才能继续执行。也就是说，池中进程的数量是固定的，那么同一时间最多有固定数量的进程在运行。这样不会增加操作系统的调度难度，还节省了开闭进程的时间，也一定程度上能够实现并发效果。

import os

import time

from multiprocessing import Pool

def func(i):

time.sleep(0.1)

print(os.getpid(),i)

if __name__ == '__main__':

p = Pool(5)

for i in range(20):

p.apply_async(func,args=(i,))

p.close()

p.join()