Question

I only know basic concepts for multi-threading, and I currently encounter a situation that needs some help.

I have two tasks to finish, and both should be executed continuously. The thing is that the second task should start only after the first thread did some jobs first. Right now the two thread classes look roughly like the following:

finished = False # shared flag 

class first(threading.Thread):
    def __init__(self, cond, finished):
        threading.Thread.__init__(self)
        self.cond = cond
        self.finished = finished

    def run(self):
        self.cond.aquire()
        do_something()
        self.finished = True #change the flag
        self.cond.notify()
        self.cond.release()
        do_something_else()


class second(threading.Thread):
    def __init__(self, cond, finished):
        threading.Thread.__init__(self)
        self.cond = cond
        self.finished = finished

    def run(self):
        self.cond.aquire()
        while self.finished == False:
            self.cond.wait()
        self.cond.release()
        do_something()

However, the fact is that the program still executes randomly regardless of the wait() and notify(). Can anybody help me with this issue? Thanks.

Answer 1

self.finished in class first is a copy of the value of the global finished, not a reference to it, so it has no live relationship to the self.finished of class second.

You should probably create a global Queue object (which is designed to be used with the threading module). Have both classes refer to the queue, and have the first thread write a go-ahead signal to the queue, and the second thread block until it reads the go-ahead.