Tkinter：等待队列中的项目

Question

我正在使用队列在后台线程和 Tk GUI 应用程序之间交换消息。目前，这是通过不时调用查询方法来完成的。

def read_queue(self):
    try:
        self.process(self.queue.get(False)) # non-blocking
    except Queue.Empty:
        pass
    finally:
        self.after(UPDATE_TIME, self.read_queue)

这种方法的问题是，如果 UPDATE_TIME 太大，应用程序处理新项目的速度将比可能的慢。如果它太小，Tk 会花费大部分时间检查队列，尽管它同时可以做其他事情。

有没有办法在新项目到达队列时自动触发 read_queue 方法？ （当后台线程填充队列时，我当然可以调用 Tk 上的方法，但我担心这会给我带来一些并发问题 - 这就是我毕竟使用队列的原因。）

Answer 1

一种选择可能是 mtTkinter http://tkinter.unpythonic.net/wiki/mtTkinter

这是使用 event_generate 的另一个示例后台线程：

##The only secure way I found to make Tkinter mix with threads is to never  
##issue commands altering the graphical state of the application in another  
##thread than the one where the mainloop was started. Not doing that often  
##leads to random behaviour such as the one you have here. Fortunately, one  
##of the commands that seems to work in secondary threads is event_generate,  
##giving you a means to communicate between threads. If you have to pass  
##information from one thread to another, you can use a Queue.
##
##This obviously complicates things a bit, but it may work far better.  
##Please note that the 'when' option *must* be specified in the call to  
##event_generate and *must not* be 'now'. If it's not specified or if it's  
##'now', Tkinter may directly execute the binding in the secondary thread's  
##context. (Eric Brunel)

import threading
import time
import Queue
from Tkinter import *

## Create main window
root = Tk()

## Communication queue
commQueue = Queue.Queue()

## Function run in thread
def timeThread():
    curTime = 0
    while 1:
        ## Each time the time increases, put the new value in the queue...
        commQueue.put(curTime)
        ## ... and generate a custom event on the main window
        try:
            root.event_generate('<<TimeChanged>>', when='tail')
        ## If it failed, the window has been destoyed: over
        except TclError:
            break
        ## Next
        time.sleep(1)
        curTime += 1

## In the main thread, do usual stuff
timeVar = IntVar()
Label(root, textvariable=timeVar, width=8).pack()

## Use a binding on the custom event to get the new time value
## and change the variable to update the display
def timeChanged(event):
    timeVar.set(commQueue.get())

root.bind('<<TimeChanged>>', timeChanged)

## Run the thread and the GUI main loop
th=threading.Thread(target=timeThread)
th.start()

root.mainloop()

还提到以类似的方式使用 after_idle 。
即。 root.after_idle(时间更改)

Answer 2

摘要：我不会使用“noob oddy's example code”——这是一种根本上有缺陷的方法。

我不是 python 专家，但“noob oddy”提供的示例代码（调用 root.event_generate(. ..）在后台线程内）似乎是一种“根本上有缺陷的方法”。即，互联网上有几篇文章指出“永远不要在‘GUI 线程’（通常是主线程）的上下文之外调用 Tkinter 函数/对象方法”。
他的示例“大部分时间”都有效，但如果增加事件生成率，则该示例的“崩溃率”将会增加——但是，具体行为取决于事件生成率和平台的性能特征。

例如，在 Python 2.7.3 中使用他的代码，如果将：更改

       time.sleep(1)

为：，

       time.sleep(0.01)

则脚本/应用程序通常会在“x”次迭代后崩溃。

经过大量搜索，如果您“必须使用 Tkinter”，那么从后台线程获取信息到 GUI 线程的最“防弹方法”似乎是使用 'after()' 小部件方法来轮询线程安全对象（例如“队列”）。例如，

################################################################################
import threading
import time
import Queue
import Tkinter      as Tk
import Tkconstants  as TkConst
from ScrolledText import ScrolledText
from tkFont       import Font

global top
global dataQ
global scrText

def thread_proc():
    x = -1
    dataQ.put(x)
    x = 0
    for i in xrange(5):
        for j in xrange(20):
            dataQ.put(x)
            time.sleep(0.1)
            x += 1
        time.sleep(0.5)
    dataQ.put(x)

def on_after_elapsed():
    while True:
        try:
            v = dataQ.get(timeout=0.1)
        except:
            break
        scrText.insert(TkConst.END, "value=%d\n" % v)
        scrText.see(TkConst.END)
        scrText.update()
    top.after(100, on_after_elapsed)

top     = Tk.Tk()
dataQ   = Queue.Queue(maxsize=0)
f       = Font(family='Courier New', size=12)
scrText = ScrolledText(master=top, height=20, width=120, font=f)
scrText.pack(fill=TkConst.BOTH, side=TkConst.LEFT, padx=15, pady=15, expand=True)
th = threading.Thread(target=thread_proc)
th.start()
top.after(100, on_after_elapsed)
top.mainloop()
th.join()
## end of file #################################################################

Answer 3

通过使用 os.pipe 在两个线程之间进行同步，可以从 Ken Mumme 解决方案中消除轮询。

tkinter 有一个 createFilehandler 方法，可用于将文件描述符添加到 tk 的选择循环中。然后，您可以通过向管道中写入一个字节来表示队列中的某些内容已准备就绪。

解决方案如下：

import Queue
import os

uiThreadQueue = Queue.Queue() ;

pipe_read, pipe_write = os.pipe() ;

# call one function from the queue.  Triggered by the 
# pipe becoming readable through root.tk.createfilehandler().
def serviceQueue(file, mask):
    os.read(pipe_read, 1) 
    func = uiThreadQueue.get() ;
    func() 

# enqueue a function to be run in the tkinter UI thread.
# best used as inUIThread(lambda: self.callSomeFunction(arg1,arg2,arg3))
def inUIThread(f):
    uiThreadQueue.put(f)
    os.write(pipe_write, "x")

... set up your widgets, start your threads, etc.....


root.tk.createfilehandler(pipe_read, tkinter.READABLE, serviceQueue)
root.mainloop()

我不是Python专家；如果我搞砸了任何编码约定，我深表歉意。不过我对管道很在行:)