5 Best Ways to Use Thread in Tkinter Python

💡 Problem Formulation: When using Tkinter for building graphical user interfaces in Python, running long-running tasks can freeze the UI because Tkinter is not thread-safe. This article will show how to use threading alongside Tkinter to perform background tasks without disrupting the user experience. Let’s say you want a Tkinter window with a button that, when clicked, starts a computationally intensive task. The goal is to complete this task without causing the UI to become unresponsive.

Method 1: Using the threading Module

Threading is a vital feature in Python to run different parts of a program concurrently. When used with Tkinter, you should avoid updating the UI directly from the thread. Instead, use a thread to handle background tasks and communicate back using thread-safe methods such as queue.Queue. It’s essential to respect the single-threaded nature of Tkinter’s GUI operations.

Here’s an example:

import tkinter as tk
from threading import Thread
import time

def background_task():
    time.sleep(5)
    print("Task completed")

def start_thread():
    thread = Thread(target=background_task)
    thread.start()

root = tk.Tk()
start_button = tk.Button(root, text="Start Task", command=start_thread)
start_button.pack()
root.mainloop()

Output: After clicking the Start Task button and waiting for 5 seconds, “Task completed” is printed to the console.

The code snippet above creates a simple Tkinter window with a button. When the button is clicked, the start_thread() function starts a new thread, which executes the background_task() function. The background task simply waits for 5 seconds and prints a message. Since the task is run on a separate thread, the Tkinter UI remains responsive.

Method 2: Using a Queue to Communicate

The queue.Queue class provides a safe way to communicate between threads in Python. When working with Tkinter, you can use it to pass messages or results back to the main thread from a worker thread. Tkinter’s main loop can poll this queue, or you can use after to check the queue at regular intervals.

Here’s an example:

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

def background_task(q):
    time.sleep(5)
    q.put("Task completed")

def check_queue(q):
    try:
        result = q.get_nowait()
        print(result)
    except queue.Empty:
        root.after(100, check_queue, q)

def start_thread(q):
    thread = Thread(target=background_task, args=(q,))
    thread.start()
    root.after(100, check_queue, q)

root = tk.Tk()
q = queue.Queue()
start_button = tk.Button(root, text="Start Task", command=lambda: start_thread(q))
start_button.pack()
root.mainloop()

Output: The Tkinter UI will remain responsive, and after 5 seconds “Task completed” will be printed to the console.

In this code snippet, we’ve introduced a queue.Queue object to safely pass messages from the threaded background task back to the main thread. The check_queue() function is called every 100 milliseconds by the Tkinter after method to check for new messages in the queue.

Method 3: Updating the UI with threading and after

Updating the UI from a separate thread can cause issues due to Tkinter’s single-thread nature. However, you can safely request UI updates from a thread by using the after method to schedule the updates to be run by the main thread.

Here’s an example:

import tkinter as tk
from threading import Thread
import time

def update_label(label):
    label.config(text="Task completed")

def background_task(root, label):
    time.sleep(5)
    root.after(0, update_label, label)

def start_thread(root, label):
    thread = Thread(target=background_task, args=(root, label))
    thread.start()

root = tk.Tk()
temperature_label = tk.Label(root, text="Waiting...")
temperature_label.pack()
start_button = tk.Button(root, text="Start Task", command=lambda: start_thread(root, temperature_label))
start_button.pack()
root.mainloop()

Output: After clicking the “Start Task” button and waiting for 5 seconds, the label text updates to “Task completed,” while the UI remains responsive.

This snippet demonstrates how to update the Tkinter UI from a thread indirectly. The background_task() notifies the main thread after a delay using the after method to update the UI, which is a safe and convenient way to request UI changes from a worker thread.

Method 4: Using a Thread-safe Variable with Tkinter

The tkinter.StringVar() is an example of a thread-safe variable in Tkinter, meaning it can be set from a worker thread without direct interaction with other TK widgets. This can be useful for updating text-based widgets like labels or entries.

Here’s an example:

import tkinter as tk
from threading import Thread
import time

def background_task(text_var):
    time.sleep(5)
    text_var.set("Task completed")

def start_thread(text_var):
    thread = Thread(target=background_task, args=(text_var,))
    thread.start()

root = tk.Tk()
task_status = tk.StringVar(value="Waiting...")
status_label = tk.Label(root, textvariable=task_status)
status_label.pack()
start_button = tk.Button(root, text="Start Task", command=lambda: start_thread(task_status))
start_button.pack()
root.mainloop()

Output: After clicking the “Start Task” button and waiting for 5 seconds, the label text updates to “Task completed” while the UI remains responsive.

This code utilizes a StringVar() which is a Tkinter object designed to hold a string value. The background_task() function can safely update this variable even from a separate thread, as it is specifically designed to cope with the single-threaded constraints of the Tkinter library.

Bonus One-Liner Method 5: Using Lambda with after for Delayed Execution

Sometimes, you just need a simple method to execute a task after a fixed delay. Using after with a lambda expression can run a function within the Tkinter main thread after a set time, which can simulate threading without actual threads.

Here’s an example:

import tkinter as tk

def task():
    print("Task completed")

root = tk.Tk()
root.after(5000, lambda: task())
root.mainloop()

Output: The console will print “Task completed” after 5 seconds, while the Tkinter UI remains responsive.

This tiny code snippet instructs Tkinter to execute a specified function after a delay. The after method schedules task() to be called after 5000 milliseconds (5 seconds). This approach can be a simple alternative to threads for delayed execution that doesn’t require simultaneous activities.

Summary/Discussion

• Method 1: Threading Module. Strengths: Direct use of Python’s threading allows for complex concurrent execution. Weaknesses: Requires careful communication back to the main UI thread to prevent conflicts.
• Method 2: Queue Communication. Strengths: Provides a thread-safe way to pass data between threads. Weaknesses: Adds complexity with queue management and periodic polling.
• Method 3: after for UI updates. Strengths: Safeguards against threading issues by handing UI updates back to the main thread. Weaknesses: Potentially less efficient if frequent updates are needed.
• Method 4: Thread-safe Variables. Strengths: Allows for safer updates to the UI from background threads using special Tkinter variables. Weaknesses: Limited to specific types of updates (e.g., text variables).
• Method 5: Lambda with after. Strengths: Simple and requires no additional threading. Weaknesses: Not suitable for actual concurrent tasks, but only for delayed execution.