Tkinter 吐槽之一：多线程与 UI 交互

背景

最近想简单粗暴的用 Python 写一个 GUI 的小程序。因为 Tkinter 是 Python 自带的 GUI 解决方案，为了部署方便，就直接选择了 Tkinter。

本来觉得 GUI 发展这么多年以来，就算功能简陋，但也应该大差不差才对，何况我的需求本就十分简单。但事实上 Tkinter 的简陋仍然超出了我的想象。因此想写几篇文章，记录一下踩到的坑，权当吐槽。

问题

众所周知，任何 GUI 程序的主线程中，都是不能执行一些比较耗时的操作的，因为这样的操作会阻塞主线程，造成 GUI 卡顿无响应。因此需要将耗时操作放在其他线程中执行。而在使用多线程机制时，需要能够确保：

1. 对数据的修改是需要线程安全的
2. 锁或者数据等待不会阻塞主 UI 线程
3. 只在主 GUI 线程中修改 GUI

然而 Tkinter 默认是没有提供这样的机制的。它并不能像很多其他框架那样，将线程的 callback 变成主线程的事件，进而在主线程中执行。这就导致了，主线程的 UI 逻辑很难与耗时操作的代码做到良好的解耦。

方案

参考其他 GUI 框架的解决方案，从编码简单的角度来说，多线程与 UI 线程最直观的使用方法，应该是使用 callback 的形式，类似这样的：

def run_in_thread():
  time.sleep(1)
  return 1

def on_data_received(num):
  # change ui
  pass

ttk.Button(frame, command=lambda: thread.submit(run_in_thread, callback=on_data_received))

如果忽略 thread 的话，这样的写法和传统的同步代码写法并没有什么区别，类似于 button.on_click = lambda: do_something()

其实，Python 中 concurrent.futures 的 Future 就有类似的方法：

def run_in_thread(n):
    time.sleep(n)
    return n * 2

def on_data_received(future):
    print(future.result())

thread_pool = ThreadPoolExecutor()
future = thread_pool.submit(run_in_thread, 3)
future.add_done_callback(on_data_received)

虽然 Future 是可以 add_callback 的，但这个回调是在子线程中执行的，并非 UI 主线程。这就会打破 Tkinter 的约束：只有主 GUI 线程可以修改 GUI。

其实，参考很多其他的 GUI 的设计来看，解决多线程与 UI 线程交互的问题，归根结底其实只有一种方案：主线程轮询是否有回调事件或者数据改变。不论是 Pub/Sub 的方案，还是 Event 的方案，本质上都是这样一种 loop。因此，我们可以在主 UI 线程中检查其他线程是否完成，进而主动触发回调。

Tkinter 中的 root.after() 正是做这种轮询的最佳方式，类似于：

def check_event(callback: Callable):
    if future.done():
        callback(future.result())
    else:
        root.after(100, check_event, callback)

在这段代码里，使用 root.after 通过递归的方式每 100ms 检查一次 future 是否完成，如果执行完成，则直接调用 callback 函数。因为 root.after 一定是在主 UI 线程中执行的，因此 callback 也是在主 UI 线程中执行。

但是每次这么写会比较麻烦，可以参考 js 中 promise 的方法做一些封装，就可以得到一些相对比较通用的工具类：

"""
The module for asynchronous running tasks in Tk GUI.
"""
import tkinter as tk
from concurrent import futures
from typing import Callable, Generic, List, TypeVar

_EVENT_PERIOD_MS = 100
_THREAD_POOL = futures.ThreadPoolExecutor(5, 'pool')

T = TypeVar('T')

class _Promise(Generic[T]):
    def __init__(self, future: futures.Future[T]) -> None:
        self._future = future
        self._on_success = None
        self._on_failure = None

    def then(self, on_success: Callable[[T], None]):
        """ Do something when task is finished. """
        self._on_success = on_success
        return self

    def catch(self, on_failure: Callable[[BaseException], None]):
        """ Do something when task is failed. """
        self._on_failure = on_failure
        return self

class AsyncEvent:
    """
    Used for asynchronous tasks in Tk GUI. It takes use of tk.after to check the
    event and do the callback in the GUI thread, so we can use it just like
    traditional "callback" way.

    The class is singleton, so it's shared in the process.

    """
    def __init__(self, master: tk.Misc) -> None:
        """ Initialize the singleton with Tk.
        Args:
            master: Same in Tk.
        """
        self._master: tk.Misc = master
        self._promise_list: List[_Promise] = []

    def submit(self, task: Callable[..., T], /, *args) -> _Promise[T]:
        """
        Adds an asynchronous task, and return a `Promise` for this task.
        We can add callback by the `Promise`.

        Args:
            task: A function which will be called asynchronously in a thread-pool.
            *args: The arguments for the function.
        Return: Promise object then you can add callback to it.
        """
        if not getattr(self, '_master', None):
            raise RuntimeError('Not initialized. Please call init() at first.')

        future = _THREAD_POOL.submit(task, *args)
        promise: _Promise[T] = _Promise(future)
        self._promise_list.append(promise)

        # If the len of event list is 1, means that it's not running.
        if len(self._promise_list) == 1:
            self._master.after(_EVENT_PERIOD_MS, self._handle_event)

        return promise

    def _handle_event(self):
        """ Works as event loop to do the callback. """
        for promise in self._promise_list:
            future = promise._future
            on_success = promise._on_success
            on_failure = promise._on_failure

            if future.done():
                if future.exception():
                    if on_failure:
                        on_failure(future.exception() or BaseException())
                    else:
                        # add log for the exception.
                elif on_success:
                    on_success(future.result())
                self._promise_list.remove(promise)

        # Try to handle events in next cycle.
        if len(self._promise_list) > 0:
            self._master.after(_EVENT_PERIOD_MS, self._handle_event)

这样的话，使用起来就会非常简单：

def run_in_thread(n):
    time.sleep(n)
    return n * 2

def print_result(n2):
    print(n2)

async_executor = AsyncEvent(root)
async_executor.submit(run_in_thread, 3).then(print_result)

这样，整个 coding 比较易读，也满足异步执行的所有要求。

总结

其实类似于 future 或者 promise 的概念在很多语言中都是支持的。在 Tkinter 中，主要的区别在于需要将异步线程的回调运行在主线程当中。因此，可以仿照其他语言的 future 或者 promise 的语法方式来进行封装，从而达到易用且符合要求的目的。

语法糖虽然不是必须的，但好看的代码，终归是赏心悦目的。