python 多进程 queue 丢数据_python 使用多进程实现并发编程/使用queue进行进程间数据交换...

importtimeimportosimportmultiprocessingfrom multiprocessing importQueue, pool"""一.Python 使用多进程实现并发编程：

因为cpython解释器中有GIL存在的原因(每个进程都会维护一个GIL，jpython解释器没有这个问题)，所以在一个进程内，

即使服务器是多核cpu，同一时刻只能有一个线程在执行任务(一个进程内)。如果存在较多IO，使用多线程是可以提高处理速度的，

但是如果是cpu密集型任务，使用多线程是有一定瓶颈的。如果需要频繁的创建和销毁任务，可以使用多线程。cpu密集型任务可以考虑使用多进程。

二.multiprocessing模块就是跨平台版本的多进程模块，提供了一个Process类来代表一个进程对象，这个对象可以理解为是一个独立的进程，可以执行另外的事情.Process语法结构如下：

Process([group [, target [, name [, args [, kwargs]]]]])

target：如果传递了函数的引用，可以任务这个子进程就执行这里的代码

args：给target指定的函数传递的参数，以元组的方式传递

kwargs：给target指定的函数传递命名参数

name：给进程设定一个名字，可以不设定

group：指定进程组，大多数情况下用不到

Process创建的实例对象的常用方法：

start()：启动子进程实例(创建子进程)

is_alive()：判断进程子进程是否还在活着

join([timeout])：是否等待子进程执行结束，或等待多少秒

terminate()：不管任务是否完成，立即终止子进程

Process创建的实例对象的常用属性：

name：当前进程的别名，默认为Process-N，N为从1开始递增的整数

pid：当前进程的pid(进程号)

三.进程间无法直接共享内存，所以需要使用Queue进行数据的交互:

初始化Queue()对象时(例如：q=Queue())，若括号中没有指定最大可接收的消息数量，或数量为负值，那么就代表可接受的消息数量没有上限(直到内存的尽头)；

Queue.qsize()：返回当前队列包含的消息数量；

Queue.empty()：如果队列为空，返回True，反之False ；

Queue.full()：如果队列满了，返回True,反之False；

Queue.get([block[, timeout]])：获取队列中的一条消息，然后将其从列队中移除，block默认值为True；

1)如果block使用默认值，且没有设置timeout(单位秒)，消息列队如果为空，此时程序将被阻塞(停在读取状态)，直到从消息列队读到消息为止，如果设置了timeout，则会等待timeout秒，若还没读取到任何消息，则抛出"Queue.Empty"异常；

2)如果block值为False，消息列队如果为空，则会立刻抛出"Queue.Empty"异常；

Queue.get_nowait()：相当Queue.get(False)；

Queue.put(item,[block[, timeout]])：将item消息写入队列，block默认值为True；

1)如果block使用默认值，且没有设置timeout(单位秒)，消息列队如果已经没有空间可写入，此时程序将被阻塞(停在写入状态)，直到从消息列队腾出空间为止，如果设置了timeout，则会等待timeout秒，若还没空间，则抛出"Queue.Full"异常；

2)如果block值为False，消息列队如果没有空间可写入，则会立刻抛出"Queue.Full"异常；

Queue.put_nowait(item)：相当Queue.put(item, False)；

注意：

多个进程同时对一个队列进行读取数据时，有可能会发生数据丢失的情况"""

defmulti_1():

# 测试主进程默认会等待子进程

time.sleep(2)print("multi_1 子进程运行结束")def multi_2(pid, name="lowman"):

# 测试向子进程的任务函数中传递参数

time.sleep(2)print("主进程的pid:{}".format(pid))

#print(name)deftest_queue_write(queue):

# 往队列中写入数据

my_list= ["L", "O", "W", "M", "A", "N"]for i inmy_list:#判断队列是否已满,这样设置的话，需要注意数据量的大小和队列的容量，否则循环写入数据的时候会造成的数据的丢失

#if not queue.full():

#queue.put(i)

#如果队列已满，就会阻塞

queue.put(i)print("test_queue_write子进程：所有数据都已写入了队列中")deftest_queue_read(queue):

# 从队列中取出数据whileTrue:#判断队列是否为空

if notqueue.empty():print(queue.get())else:break

deftest_multi():#创建一个子进程，并将需要执行的目标函数使用target参数进行传递

p = multiprocessing.Process(target=multi_1)#args：给固定参数传参，最后必须带一个逗号 "，" kwargs：给命名参数传参

p_2 = multiprocessing.Process(target=multi_2, args=(os.getpid(), ), kwargs={"name": "xienuo"})#p 子进程 守护主进程,当主进程执行完成以后，主进程不会等待 p 子进程

#p.daemon = True

#启动子进程，默认情况主进程会守护所有子进程，等所有子进程运行结束后，才会退出

p.start()

p_2.start()#主进程执行完毕，直接销毁 p 子进程,不管子进程是否已执行完毕，和daemon具有相似的功能

#p.terminate()

#等待 p 子进程结束后再执行下一步

#p.join()

#等待 p_2 子进程结束后再执行下一步

#p_2.join()

#父进程创建Queue，并传给各个子进程,可以设置队列的上限，不设置则表示没有上限

q =Queue()

pw= multiprocessing.Process(target=test_queue_write, args=(q,))

pr= multiprocessing.Process(target=test_queue_read, args=(q,))

pw.start()#这里设置成了让写操作先完成, 再进行读操作(阻塞)，这样设置的话其实就相当于是同步执行，影响了性能

pw.join()

pr.start()print("默认情况下：主进程运行结束，会等待子进程")

test_multi()