Tkinter How to use threads to preventing main event loop from freezing

Question

I have a small GUI test with a  Start  button and a Progress bar  The desired behavior is    Click Start Progressbar oscillates for 5 seconds Progressbar stops   The observed behavior is the  Start  button freezes for 5 seconds  then a Progressbar is displayed  no oscillation    Here is my code so far   class GUI      def   init   self  master           self master   master         self test button   Button self master  command self tb click          self test button configure              text  Start   background  Grey               padx 50                       self test button pack side TOP       def progress self           self prog bar   ttk Progressbar              self master  orient  horizontal               length 200  mode  indeterminate                        self prog bar pack side TOP       def tb click self           self progress           self prog bar start             Simulate long running process         t   threading Thread target time sleep  args  5            t start           t join           self prog bar stop    root   Tk   root title  Test Button   main ui   GUI root  root mainloop     Based on the information from Bryan Oakley here  I understand that I need to use threads  I tried creating a thread  but I m guessing that since the thread is started from within the main thread  it doesn t help   I had the idea to place the logic portion in a different class  and instantiate the GUI from within that class  similar to the example code by A  Rodas here   My question   I can t figure out how to code it so that this command   self test button   Button self master  command self tb click    calls a function that is located in the other class  Is this a Bad Thing to do or is it even possible  How would I create a 2nd class that can handle the self tb click  I tried following along to A  Rodas  example code which works beautifully  But I cannot figure out how to implement his solution in the case of a Button widget that triggers an action   If I should instead handle the thread from within the single GUI class  how would one create a thread that doesn t interfere with the main thread

User · Answer

I will submit the basis for an alternate solution. It is not specific to a Tk progress bar per se, but it can certainly be implemented very easily for that.

Here are some classes that allow you to run other tasks in the background of Tk, update the Tk controls when desired, and not lock up the gui!

Here's class TkRepeatingTask and BackgroundTask:

import threading

class TkRepeatingTask():

    def __init__( self, tkRoot, taskFuncPointer, freqencyMillis ):
        self.__tk_   = tkRoot
        self.__func_ = taskFuncPointer        
        self.__freq_ = freqencyMillis
        self.__isRunning_ = False

    def isRunning( self ) : return self.__isRunning_ 

    def start( self ) : 
        self.__isRunning_ = True
        self.__onTimer()

    def stop( self ) : self.__isRunning_ = False

    def __onTimer( self ): 
        if self.__isRunning_ :
            self.__func_() 
            self.__tk_.after( self.__freq_, self.__onTimer )

class BackgroundTask():

    def __init__( self, taskFuncPointer ):
        self.__taskFuncPointer_ = taskFuncPointer
        self.__workerThread_ = None
        self.__isRunning_ = False

    def taskFuncPointer( self ) : return self.__taskFuncPointer_

    def isRunning( self ) : 
        return self.__isRunning_ and self.__workerThread_.isAlive()

    def start( self ): 
        if not self.__isRunning_ :
            self.__isRunning_ = True
            self.__workerThread_ = self.WorkerThread( self )
            self.__workerThread_.start()

    def stop( self ) : self.__isRunning_ = False

    class WorkerThread( threading.Thread ):
        def __init__( self, bgTask ):      
            threading.Thread.__init__( self )
            self.__bgTask_ = bgTask

        def run( self ):
            try :
                self.__bgTask_.taskFuncPointer()( self.__bgTask_.isRunning )
            except Exception as e: print repr(e)
            self.__bgTask_.stop()

Here's a Tk test which demos the use of these. Just append this to the bottom of the module with those classes in it if you want to see the demo in action:

def tkThreadingTest():

    from tkinter import Tk, Label, Button, StringVar
    from time import sleep

    class UnitTestGUI:

        def __init__( self, master ):
            self.master = master
            master.title( "Threading Test" )

            self.testButton = Button( 
                self.master, text="Blocking", command=self.myLongProcess )
            self.testButton.pack()

            self.threadedButton = Button( 
                self.master, text="Threaded", command=self.onThreadedClicked )
            self.threadedButton.pack()

            self.cancelButton = Button( 
                self.master, text="Stop", command=self.onStopClicked )
            self.cancelButton.pack()

            self.statusLabelVar = StringVar()
            self.statusLabel = Label( master, textvariable=self.statusLabelVar )
            self.statusLabel.pack()

            self.clickMeButton = Button( 
                self.master, text="Click Me", command=self.onClickMeClicked )
            self.clickMeButton.pack()

            self.clickCountLabelVar = StringVar()            
            self.clickCountLabel = Label( master,  textvariable=self.clickCountLabelVar )
            self.clickCountLabel.pack()

            self.threadedButton = Button( 
                self.master, text="Timer", command=self.onTimerClicked )
            self.threadedButton.pack()

            self.timerCountLabelVar = StringVar()            
            self.timerCountLabel = Label( master,  textvariable=self.timerCountLabelVar )
            self.timerCountLabel.pack()

            self.timerCounter_=0

            self.clickCounter_=0

            self.bgTask = BackgroundTask( self.myLongProcess )

            self.timer = TkRepeatingTask( self.master, self.onTimer, 1 )

        def close( self ) :
            print "close"
            try: self.bgTask.stop()
            except: pass
            try: self.timer.stop()
            except: pass            
            self.master.quit()

        def onThreadedClicked( self ):
            print "onThreadedClicked"
            try: self.bgTask.start()
            except: pass

        def onTimerClicked( self ) :
            print "onTimerClicked"
            self.timer.start()

        def onStopClicked( self ) :
            print "onStopClicked"
            try: self.bgTask.stop()
            except: pass
            try: self.timer.stop()
            except: pass                        

        def onClickMeClicked( self ):
            print "onClickMeClicked"
            self.clickCounter_+=1
            self.clickCountLabelVar.set( str(self.clickCounter_) )

        def onTimer( self ) :
            print "onTimer"
            self.timerCounter_+=1
            self.timerCountLabelVar.set( str(self.timerCounter_) )

        def myLongProcess( self, isRunningFunc=None ) :
            print "starting myLongProcess"
            for i in range( 1, 10 ):
                try:
                    if not isRunningFunc() :
                        self.onMyLongProcessUpdate( "Stopped!" )
                        return
                except : pass   
                self.onMyLongProcessUpdate( i )
                sleep( 1.5 ) # simulate doing work
            self.onMyLongProcessUpdate( "Done!" )                

        def onMyLongProcessUpdate( self, status ) :
            print "Process Update: %s" % (status,)
            self.statusLabelVar.set( str(status) )

    root = Tk()    
    gui = UnitTestGUI( root )
    root.protocol( "WM_DELETE_WINDOW", gui.close )
    root.mainloop()

if __name__ == "__main__": 
    tkThreadingTest()

Two import points I'll stress about BackgroundTask:

1) The function you run in the background task needs to take a function pointer it will both invoke and respect, which allows the task to be cancelled mid way through - if possible.

2) You need to make sure the background task is stopped when you exit your application. That thread will still run even if your gui is closed if you don't address that!

User · Answer

When you join the new thread in the main thread  it will wait until the thread finishes  so the GUI will block even though you are using multithreading   If you want to place the logic portion in a different class  you can subclass Thread directly  and then start a new object of this class when you press the button  The constructor of this subclass of Thread can receive a Queue object and then you will be able to communicate it with the GUI part  So my suggestion is    Create a Queue object in the main thread Create a new thread with access to that queue Check periodically the queue in the main thread   Then you have to solve the problem of what happens if the user clicks two times the same button  it will spawn a new thread with each click   but you can fix it by disabling the start button and enabling it again after you call self prog bar stop     import Queue  class GUI                 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 0                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           threading Thread   init   self          self queue   queue     def run self           time sleep 5     Simulate long running process         self queue put  Task finished

User · Answer

The problem is that t join   blocks the click event  the main thread does not get back to the event loop to process repaints  See Why ttk Progressbar appears after process in Tkinter or TTK progress bar blocked when sending email

User · Answer

I have used RxPY which has some nice threading functions to solve this in a fairly clean manner  No queues  and I have provided a function that runs on the main thread after completion of the background thread  Here is a working example  import rx from rx scheduler import ThreadPoolScheduler import time import tkinter as tk  class UI     def   init   self         self root   tk Tk         self pool scheduler   ThreadPoolScheduler 1    thread pool with 1 worker thread       self button   tk Button text  quot Do Task quot   command self do task  pack       def do task self         rx empty   subscribe           on completed self long running task            scheduler self pool scheduler             def long running task self           your long running task here    eg        time sleep 3          if you want a callback on the main thread        self root after 5  self on task complete      def on task complete self          pass   runs on main thread  if   name       quot   main   quot       ui   UI       ui root mainloop    Another way to use this construct which might be cleaner  depending on preference   tk Button text  quot Do Task quot   command self button clicked  pack         def button clicked self       def do task           time sleep 3    runs on background thread                  def on task done          pass   runs on main thread     rx just 1  subscribe        on next do task         on completed lambda  self root after 5  on task done          scheduler self pool scheduler

[python] Tkinter: How to use threads to preventing main event loop from "freezing"

Examples related to python

Examples related to multithreading

Examples related to tkinter

Examples related to progress-bar

Examples related to event-loop