python之一个易于刷新的 Python 线程队列_编程设计

我想找到一种机制来轻松地报告 Python 线程的进度。例如，如果我的线程有一个计数器，我想偶尔知道计数器的值，但重要的是，我只需要知道最新的值，而不是所有过去的值。

我认为最简单的解决方案是单值队列，每次我在线程中放置一个新值时，它都会用新值替换旧值。然后当我在主程序中执行 get 时，它只会返回最新的值。

因为我不知道如何执行上述操作，所以我所做的是将每个计数器值放入队列中，当我get时，我得到了所有值直到没有更多，只保留最后一个。但这似乎远非理想，因为我正在用我不关心的数千个值填充队列。

这是我现在做的一个例子:

from threading import Thread 
from Queue import Queue, Empty 
from time import sleep 
 
N = 1000 
 
def fast(q): 
    count = 0 
    while count<N: 
        sleep(.02) 
        count += 1 
        q.put(count) 
 
def slow(q): 
    while 1: 
        sleep(5)  # sleep for a long time 
        # read last item in queue 
        val = None 
        while 1:  # read all elements of queue, only saving last 
            try: 
                val = q.get(block=False) 
            except Empty: 
                break 
        print val   # the last element read from the queue 
        if val==N: 
            break 
 
if __name__=="__main__": 
    q = Queue() 
    fast_thread = Thread(target=fast, args=(q,)) 
    fast_thread.start() 
    slow(q) 
    fast_thread.join()

我的问题是，是否有更好的方法？

请您参考如下方法:

只需使用一个全局变量和一个 threading.Lock 来在赋值期间保护它:

import threading 
from time import sleep 
 
N = 1000 
value = 0 
def fast(lock): 
    global value 
    count = 0 
    while count<N: 
        sleep(.02) 
        count += 1 
        with lock: 
            value = count 
 
def slow(): 
    while 1: 
        sleep(5)  # sleep for a long time 
        print value   # read current value 
        if value == N: 
            break 
 
if __name__=="__main__": 
    lock = threading.Lock() 
    fast_thread = threading.Thread(target=fast, args=(lock,)) 
    fast_thread.start() 
    slow() 
    fast_thread.join()

产量(类似)

正如 Don Question 指出的那样，如果只有一个线程修改 value，那么实际上 fast 函数不需要锁。正如达诺指出的那样，如果你想确保打印在 slow 中的值与在 if-statement，那么在slow函数中需要一个锁。

有关何时需要锁的更多信息，请参阅 Thread Synchronization Mechanisms in Python .