Python线程：等待线程停止然后执行函数

Question

I'm trying to run a function after my thread has completed but the function is not called. Code structure:

class():

    def functiontocall()  # uses data calculated in thread for plotting. only works when thread is complete
        do something with self.A

    def watchthread():
        thread()
        functiontocall()
        # since this function depends on variable A, it throws an error.
        # I tried: if thread.join == True: functiontocall but this did not call the function.

    def thread():
        def run():
            pythoncom.CoInitialize()
            --- do stuff --
            for i in 1000:
                thousands of calculations while updating state in GUI ---
            A = result
            self.A = A
        thread = threading.Thread(target=run)
        thread.start()

note: i removed 'self' for simplicity.

thread.join should tell me when the thread has finished but for some reason i still cant run the functiontocall.

Is this a bad way of organizing threads in general?

Edit: I can call the function after the thread is finished but I cannot access variables when the thread is running. eg 0-100% progress for a progress bar in my GUI. when I use:

def watchthread():
    thread()
    thread.join()
    functiontocall()

I cannot update the status of the thread in my GUI. It just waits until the calculations are finished then runs functiontocall().

Answer 1

Because you're using threads, once the thread had started Python will move onto the next thing, it will not wait for the thread to finish unless you've asked it to.

With your code, if you want to wait for the thread function to finish before moving on then it doesn't sound like you need threading, a normal function would run, complete, and then Python will move onto running functiontocall()

If there's a reason you need to use threads which isn't coming across in the example then I would suggest using a thread.join()

threads = []  # list to hold threads if you have more than one
t = threading.Thread(target=run)
threads.append(t)

for thread in threads:  # wait for all threads to finish
    thread.join() 

functiontocall()  # will only run after all threads are done

Again, I'd suggest relooking at whether threads is what you need to use here as it doesn't seem apparent.

To update this answer based on the new information, this may be the way you want to have a variable be accessible. In this case the threads would all update your class variable A, your GUI update function also reads this periodically and updates your GUI.

class ThisClass():

    def __init__(self):
        self.A = 0

    def function_to_call(self):
        while self.A != 100:  # assuming this is a progress bar to 100%
            # update in GUI

    def run(self):
        # does calculations
        with lock: # to prevent issues with threads accessing variable at the same time
            self.A += calculations

    def progress(self):
        threads = []  # list to hold threads if you have more than one
        t = threading.Thread(target=run)
        threads.append(t)

        f = threading.Thread(target=self.function_to_call)
        threads.append(f)

        for thread in threads:
            thread.start()

        for thread in threads:  # wait for all threads to finish
            thread.join()