尝试使用tkinter运行线程（tkinter在主线程上）执行任务，但会暂停主线程

Question

I am new to Python and currently developing a small application for personal use. I am using tkinter for my gui.

What I am trying to do is create a Toplevel popup with a Label on it that changes text depending on how the login attempts are going. So while the main thread where tk is running on displays the popup with the dynamic text I want to start a thread to attempt to login at most 5 times and report back to the main thread by setting global variables called 'logindata'.

The _login() method in AuctioneerGUI and the LoginThread class are really the only things that matter here you can ignore the rest but they may deem relevant.

The _login() method is called when the login button is pressed. All this does is attempt to login and set the logindata. The main thread meanwhile is looping until it notices that the LoginThread has set the variable and when it has collected all three it will go through to the rest of the logic (which is not fully implemented but is irrelevant to the issue)

What happens now is the main thread halts after the LoginThread has been started and only continues when it has finished. Even though the LoginThread should be running in a seperate thread and thus not halt the main thread. So the popup only gets displayed after the task LoginThread performs is done. I would like the popup to just appear and show the label that gives update to the user. How do I do this?

I am certain the problem is the thread halting the main thread because I determined this using prints.

Also I have one more small question. popup.destroy() doesn't seem to do anything. The TopLevel just stays there.

Sorry for the wall of text and thanks in advance for helping me. I have already spent more time than I should have trying several different things but I didn't manage to get it working.

Let me know if something is unclear and don't mind the sometimes inefficient or silly logic, I first want to make it at least functional before making it pretty.

-Daan

global logindata
logindata = {"counter": -1, "status": -1, "success": -1}

class AuctioneerGUI:
    def __init__(self):
        root = Tk()
        root.title("Path of Exile Auctioneer")
        self._setupGUI(root)
        self._loggingin = False

        root.protocol("WM_DELETE_WINDOW", lambda: root.quit())
        root.mainloop()           

    def _setupGUI(self, root):            
        frame = Frame(root)

        email = StringVar()
        pass_ = StringVar()
        thread = StringVar()

        email.set("email")
        pass_.set("password")
        thread.set("76300")

        email_label = Label(frame, text="email")
        self._email_box = Entry(frame, takefocus=True, width=50, textvariable=email)
        self._email_box.focus_set()
        pass_label = Label(frame, text="password")
        self._pass_box = Entry(frame, takefocus=True, show="*", width=50, textvariable=pass_)
        thread_label = Label(frame, text="thread id")
        self._thread_box = Entry(frame, takefocus=True, width=10, textvariable=thread)
        self._login_button = Button(frame, text="login", command=lambda: self._login(root), takefocus=True)

        frame.pack()
        email_label.pack()
        self._email_box.pack()
        pass_label.pack()
        self._pass_box.pack()
        thread_label.pack()
        self._thread_box.pack()
        self._login_button.pack()

    def _login(self, root):
        self._login_button.configure(command=None)
        email = self._email_box.get()
        pass_ = self._pass_box.get()
        thread = self._thread_box.get()
        # Check email validity
        # no whitespaces, 1 @ sign 1 . after the @ sign
        try:
            thread = int(thread)
        except ValueError:
            return -1
            #invalid thread

        if not re.match(r"[^@]+@[^@]+\.[^@]+", email) or not email.find(" ") == -1:
            return -1
            #invalid mail

        self._sm = SessionManager(email, pass_, thread)    

        self._message = StringVar()
        self._message.set("Attempt 1/5.")

        popup = Toplevel(root)
        popup.title("Logging in...")
        message_label = Label(popup, text = self._message.get(), textvariable = self._message)
        message_label.pack()

        _thread = LoginThread(self._sm)        
        _thread.start()

        loop = True                

        while loop:
            counter = -1
            success = -1
            status = -1
            while counter == -1:
                counter = logindata["counter"]
                print(counter)
            while success == -1:
                success = logindata["success"]
            print(success)
            while status == -1:
                status = logindata["status"]
            print(status)
            if success:
                self._message.set("Attempt {}/5. Success.".format(counter))
            elif status == 200:
                self._message.set("Attempt {}/5. Failed: wrong password.".format(counter))
            else:
                self._message.set("Attempt {}/5. Failed: connection error. {}".format(counter, status))
            updatebar = not success
            logindata["counter"] = -1
            logindata["status"] = -1
            logindata["success"] = -1
            if counter == 5:
                break

        popup.destroy()
        self._login_button["command"] = lambda: self._login(root)
        self._setup_main_layout(root)

    def _setup_main_layout(self, root):
        pass

class LoginThread(threading.Thread):

    def __init__(self, sessionmanager):
        threading.Thread.__init__(self)
        self._sm = sessionmanager

    def run(self):
        success = False
        counter = 1
        while not success:
            if counter > 5:
                break

            data = self._sm.login()
            status = data[1]
            success = data[0]
            logindata["counter"] = counter
            logindata["success"] = success
            logindata["status"] = status
            counter += 1
            print("done")

update:

After some research I will solve the problem by creating a ThreadSafeLabel that inherits from label that is piped to Widget and communicates through a queue like in this example:

http://effbot.org/zone/tkinter-threads.htm

Answer 1

The proper way to start a threading.Thread is by calling the start method, not the run method. It is the start method that spawns a new thread. Without it, you are actually running LoginThread.run in the main thread.

So instead try:

    _thread = LoginThread(self._sm)        
    _thread.start()

---

From the docs :

Once a thread object is created, its activity must be started by calling the thread's start() method. This invokes the run() method in a separate thread of control.

Answer 2

Zeroth, as unutbu points out, you're just running the other thread's run function in the main thread, so nothing's going to happen until its done.

---

Once you solve that, you never, ever want to have a thread spin while waiting for a variable to change, as you do here:

while counter == -1:
    counter = logindata["counter"]
    print(counter)

The main thread cannot possibly do anything else but spin here, until the background thread sets logindata["counter"] to something else. If you force the main thread to wait until the other thread is done, you might as well run the other code in the main thread. Your code has the same effect as doing things single-threaded, except that it also burns as much CPU as possible checking the value over and over for no reason.

If you need to wait until something is done, you need to use some kind of cross-thread signal—eg, a threading.Condition or a queue.Queue .

---

However, that still won't solve your problem, because the main thread will still be stuck inside the _login function until login is done. This means it can't do other things like redraw the screen, handle mouse clicks, etc.

So, even if you solved the first two problems and got things working, this would still be exactly the same as not spawning a thread, and just doing the login in the main thread.

What you need is a _login function that returns immediately after kicking off the background thread, and then use some other mechanism to trigger an event on the tkinter loop from the background thread.