Congelamento/travamento da GUI do tkinter ao aguardar a conclusão do thread

Um problema comum ao trabalhar com o kit de ferramentas da GUI do tkinter em Python é encontrar uma interface congelada ou suspensa ao executar determinadas operações. Isso geralmente ocorre devido ao uso de operações de bloqueio, como unir threads, dentro do loop de evento principal.

Compreendendo o tkinter Mainloop

O tkinter mainloop() é responsável por lidar com a entrada do usuário e atualizar a GUI. Ele é executado continuamente em um único thread, recebendo e processando eventos. Qualquer operação que bloqueie o mainloop, como aguardar a conclusão de um thread, pode fazer com que a GUI pare de responder.

Solução: usando o método After para tarefas assíncronas

Para evitar o bloqueio do mainloop, considere usar o método after(), que permite agendar tarefas para serem executadas em intervalos específicos. Ao pesquisar periodicamente uma fila ou executar outras tarefas em segundo plano, você pode garantir que a GUI permaneça responsiva.

Separando GUI e tarefas assíncronas

Para implementar isso, separe a lógica da GUI da tarefa assíncrona. Crie uma classe que lide com a GUI, processando mensagens de uma fila dentro de um método after() agendado regularmente. Em outro thread, execute a tarefa assíncrona e preencha a fila com mensagens conforme necessário.

Código de exemplo

from threading import Thread
from queue import Queue
import tkinter as tk

class GuiPart:
    def __init__(self, master, queue):
        self.queue = queue
        # Set up GUI elements here

    def process_incoming(self):
        while not self.queue.empty():
            message = self.queue.get()
            # Process and handle the message here

class AsynchronousTask:
    def __init__(self, queue):
        self.queue = queue

    def run(self):
        # Perform asynchronous task here
        # Put messages into the queue as needed

def start_gui():
    root = tk.Tk()
    queue = Queue()
    gui = GuiPart(root, queue)
    async_task = AsynchronousTask(queue)
    # Start the asynchronous task in a separate thread
    t = Thread(target=async_task.run)
    t.start()
    # Start the GUI mainloop
    root.mainloop()

if __name__ == "__main__":
    start_gui()

Este código demonstra como separar a lógica da GUI da tarefa assíncrona, garantindo que a GUI permaneça responsiva enquanto a tarefa é executada em segundo plano.