Using Threads to Unfreeze Main Event Loop

Often, GUI elements, such as progress bars, will "freeze" while intensive operations are executed in the main thread. This happens because the main event loop, which handles user interactions and GUI updates, is blocked. To prevent this, multithreading can be employed to run the long-running tasks in a separate thread.

In the specific scenario given, a button click should initiate a progress bar animation for five seconds. However, the observed behavior is that the button freezes during this duration. This can be resolved by using threads, but the joining of the thread in the main thread causes it to wait until completion, effectively blocking the GUI.

Alternative Approach: Separate Logic into Classes

Instead of handling everything within a single GUI class, it's possible to place the logic portion in a different class and instantiate the GUI from that class. However, this requires a way to call the logic class method from the GUI class.

Solution Using Threading

To address this issue, using the Queue object to communicate between the GUI class and the logic class can be considered. The following steps outline this approach:

1. Create a Queue object in the main thread.
2. Start a new thread with access to the queue.
3. Periodically check the queue from the main thread.

Code Implementation

Below is an example implementation using a threaded task to handle the progress bar animation:

import queue

class GUI:
    # Code for GUI setup goes here

    def tb_click(self):
        self.progress()
        self.prog_bar.start()
        self.queue = queue.Queue()
        ThreadedTask(self.queue).start()
        self.master.after(100, self.process_queue)

    def process_queue(self):
        try:
            msg = self.queue.get_nowait()
            # Show result of the task if needed
            self.prog_bar.stop()
        except queue.Empty:
            self.master.after(100, self.process_queue)

class ThreadedTask(threading.Thread):
    def __init__(self, queue):
        super().__init__()
        self.queue = queue
    def run(self):
        time.sleep(5)  # Simulate long running process
        self.queue.put("Task finished")

This approach effectively keeps the main thread running and responsive while the long-running task is executed in a separate thread.