Python 3.x 如何获得多处理队列的确切大小？？？医生说是'；这不可靠。有办法解决这个问题吗？

我有这个代码，它有两个进程 一个排队，另一个退队

我需要每60秒检查一次队列大小。 q、 size（）确实给出了结果，但我希望结果应该是准确的。 那么还有其他方法吗

确切地说，我需要监控每分钟队列的输入和输出以及每分钟队列的大小

from multiprocessing import Queue, Process
import os
import time
import datetime as dt
import statsd
import random

statsd_client = statsd.StatsClient(host="localhost", port=8125, 
prefix=None, maxudpsize=512, ipv6=False)


q = Queue()


#put_timer = statsd_client.timer('put')
def queue_add_proc1():
    print("process 1 Id :", os.getpid())
    print("adding items to queue")
    x = 0
    upload_time = time.time()

    enque_count=0

    while x < 10000:
        #put_timer.start()
        curr_time = time.time()
        if curr_time - upload_time > 60:
            statsd_client.incr('enque_count_everyMinute', enque_count)
            statsd_client.incr('queue_size_enqueing', q.qsize())

            print("metric sent")
            enque_count = 0
            upload_time = curr_time
        q.put(x*2)
        #put_timer.stop(send=True)
        print("added to queue")
        x =x+ 1
        enque_count+=1
        time.sleep(0.014)
        print("done")


#pop_timer = statsd_client.timer('get')
def queue_pop_proc2():
    print("Process 2 ID :",os.getpid())
    print("popping values from queue")
    upload_time = time.time()
    deque_count = 0
    while not q.empty():
        curr_time = time.time()
        if curr_time - upload_time > 60:
            # upload dequed count
            statsd_client.incr('deque_count_everyMinute', deque_count)
            statsd_client.incr('queue_size_dequeing', q.qsize())
            print("metric sent")
            deque_count = 0
            upload_time = curr_time

        print(" popped item ", q.get())
        print("dequeued")
        deque_count += 1
        time.sleep(0.03)


if __name__ == '__main__':
    msgs_added_each_minute = list()
    msgs_popped_each_minute = list()

    print("Main process ID :", os.getpid())

    p1 = Process(target=queue_add_proc1)

    p2 = Process(target=queue_pop_proc2)

    p1.start()
    p2.start()

    p2.join()
    p1.join()

来自多处理导入队列，进程
导入操作系统
导入时间
将日期时间导入为dt
进口统计数据
随机输入
statsd_client=statsd.statclient（host=“localhost”，port=8125，
前缀=无，maxudpsize=512，ipv6=假）
q=队列（）
#put_timer=statsd_client.timer（'put'）
def queue_add_proc1（）：
打印（“进程1 Id:，os.getpid（））
打印（“将项目添加到队列”）
x=0
上传时间=time.time（）
enque_计数=0
当x<10000时：
#put_timer.start（）
curr_time=time.time（）
如果当前时间-上载时间>60：
statsd_client.incr（每分钟一次，每分钟一次）
statsd_client.incr（'queue_size_enqueing'，q.qsize（））
打印（“已发送公制”）
enque_计数=0
上传时间=当前时间
q、 put（x*2）
#put_timer.stop（发送=真）
打印（“添加到队列”）
x=x+1
enque_计数+=1
睡眠时间（0.014）
打印（“完成”）
#pop_timer=statsd_client.timer（'get'））
def queue_pop_proc2（）：
打印（“进程2 ID:，os.getpid（））
打印（“从队列中弹出值”）
上传时间=time.time（）
deque_计数=0
而不是q.empty（）：
curr_time=time.time（）
如果当前时间-上载时间>60：
#上传请求计数
statsd_client.incr（‘每分钟一次计数’、每分钟一次计数）
statsd_client.incr（'queue_size_dequeing'，q.qsize（））
打印（“已发送公制”）
deque_计数=0
上传时间=当前时间
打印（“弹出项”，q.get（））
打印（“出列”）
deque_计数+=1
睡眠时间（0.03）
如果uuuu name uuuuuu='\uuuuuuu main\uuuuuuu'：
msgs每分钟添加一次=列表（）
msgs每分钟弹出一次=列表（）
打印（“主进程ID:，os.getpid（））
p1=进程（目标=队列\添加\进程1）
p2=进程（目标=队列\u pop\u proc2）
p1.开始（）
p2.start（）
p2.join（）
p1.join（）

队列.qsize（）的结果是准确的。不准确之处在于用户经常使用它的方式

由于

队列

在不同线程/进程之间并发共享，当进程A检查其大小时，进程B可能会交错执行并更改它。这可能导致逻辑问题

考虑以下示例：

queue.put("something")

def process_a(queue):
    """Does something if queue has at least one element."""
    if queue.qsize() > 0:
        # now, Process B takes over and steals the only element in the queue
        element = queue.get()  # UNEXPECTED: process A will block here 
        do_something(element)

def process_b(queue):
    """Gets an element from the queue."""
    queue.get()

a = Process(process_a, args=(queue,))
b = Process(process_b, args=(queue,))
a.start()
b.start()

这里的问题是逻辑依赖于特定于队列的状态并对其进行操作。然而，在并发场景中，队列状态可能会在任何时候发生变化。因此，上述逻辑将无法按预期工作

对于您的特定用例，这不应该是一个问题，因为您所做的是监视某个时间点的队列状态。因此，您不在乎队列在一毫秒后是否具有不同的大小。您关心的是队列的平均吞吐量

queue.qize（）应该是queue.qsize（）吗？