Unable to terminate a python program

Question

As suggested over here, I have created a separate class, exclusively for Tkinter. The main function just gets the scale values from the Tkinter GUI. Though I'm able to get these scale values, I am unable to exit the program after closing the GUI. My program just seems to be stuck after self.root.mainloop() i.e print "mainloop" gets executed. I do not have any problems in terminating the script, if I do something as follows, i.e, if I do not access the output_q values

i = 0
while app.run:
 print i
 i = i+1

The entire code is given below

from Tkinter import *
import threading, time, sys, Queue

class App(threading.Thread):

    def __init__(self, var):
        threading.Thread.__init__(self) 
        self.output_q = Queue.Queue()      
        self.start()

    def callback(self):
        self.run = 0
        self.root.quit()
        self.root.destroy()

    def pub_y(self, val_y):  
        self.x_val = float(self.y_scale.get())
        self.output_q.put((self.x_val, 2, 3)) 

    def run(self):

        self.root = Tk()
        self.root.protocol("WM_DELETE_WINDOW", self.callback)

        self.y_var = DoubleVar()             
        self.y_scale = Scale( self.root, from_=0, to=1, length=300, label="yaw", resolution=0.0000000000001, variable = self.y_var, orient=HORIZONTAL, command=self.pub_y)
        self.y_scale.set(0.5)
        self.y_scale.pack(anchor=CENTER)

        label = Label(self.root, text="Hello World")
        label.pack()

        self.root.mainloop()
        print "mainloop"

var = 1
input = Queue.Queue()
input.put((1,2,3))
app = App(input)
i = 0  
while app.run:
 result = app.output_q.get()
 print result[0]

sys.exit(0)

Could someone point out where I might be going wrong? Thanks!

Answer 1

There are multiple things about your code that are confusing but not actually wrong, like the fact that you shadow your run method with an instance attribute with the value 0…

The fact that you’re using tkinter from a background thread actually is wrong, and can lead to a hang on some platforms. But it probably isn’t the cause here.

Your actual problem is the queue logic. Think about how it works:

• Your main thread checks whether the thread is running.
• Your main thread calls output_q.get(), which blocks forever until something gets put on the queue.
• Your background thread gets a destroy event.
• Your background thread sets run = 0 and exits.
• Your main thread is still waiting on the queue forever, so it will never see that run is now falsely, so it will never exit.

---

One way to solve this is to use the same queue that you’re already using to wake up the main thread so it can see that you’ve quit:

def callback(self):
    self.run = 0
    self.root.quit()
    self.root.destroy()
    self.output_q.put(None)

Of course now you can’t just use result[0], because result could be None, so you need to add:

if result is not None:

---

But there’s still a problem: variables that you change in one thread are guaranteed to eventually be visible to other threads, but not immediately. What happens if the main thread doesn’t see the change until after its gone to block on the queue again? It’s stuck forever.

I’m pretty sure this will work on CPython, but that isn’t guaranteed, it just happens to be true by accident, and it may not work on a different implementation like Jython. The right way to fix this is to synchronize all access to any variables you want to share between threads by using a Lock or Condition or Queue or other sync object.

But notice that you don’t actually need the while app.run: test anymore, because you can just do this:

while True:
    result = app.output_q.get()
    if result is None:
        break
    print result[0]

And then you don’t have to worry about races. Your code is simpler, and guaranteed correct, this way.