Question

I’m writing an application that listens for sound events (using messages passed in with Open Sound Control), and then based on those events pauses or resumes program execution. My structure works most of the time but always bombs out in the main loop, so I’m guessing it’s a thread issue. Here’s a generic, simplified version of what I’m talking about:

import time, threading

class Loop():
    aborted = False

    def __init__(self):
        message = threading.Thread(target=self.message, args=((0),))
        message.start()

        loop = threading.Thread(target=self.loop)
        loop.start()


    def message(self,val):

        if val > 1:
            if not self.aborted:
                self.aborted = True
                # do some socket communication            
            else:
                self.aborted = False
                # do some socket communication


    def loop(self):
        cnt = 0

        while True:
            print cnt
            if self.aborted:
                while self.aborted:
                    print "waiting"
                    time.sleep(.1);
            cnt += 1


class FakeListener():
    def __init__(self,loop):
        self.loop = loop
        listener = threading.Thread(target=self.listener)
        listener.start()

    def listener(self):
        while True:
            loop.message(2)
            time.sleep(1)



if __name__ == '__main__':

    loop = Loop()

    #fake listener standing in for the real OSC event listener
    listener = FakeListener(loop)

Of course, this simple code seems to work great, so it’s clearly not fully illustrating my real code, but you get the idea. What isn’t included here is also the fact that on each loop pause and resume (by setting aborted=True/False) results in some socket communication which also involves threads.

What always happens in my code is that the main loop doesn’t always pickup where it left off after a sound event. It will work for a number of events but then eventually it just doesn’t answer.

Any suggestions for how to structure this kind of communication amongst threads?

UPDATE:

ok, i think i’ve got it. here’s a modification that seems to work. there’s a listener thread that periodically puts a value into a Queue object. there’s a checker thread that keeps checking the queue looking for the value, and once it sees it sets a boolean to its opposite state. that boolean value controls whether the loop thread continues or waits.

i’m not entirely sure what the q.task_done() function is doing here, though.

import time, threading
import Queue

q = Queue.Queue(maxsize = 0)

class Loop():
    aborted = False

    def __init__(self):
        checker = threading.Thread(target=self.checker)
        checker.setDaemon(True)
        checker.start()

        loop = threading.Thread(target=self.loop)
        loop.start()


    def checker(self):
        while True:
            if q.get() == 2:
                q.task_done()
                if not self.aborted:
                    self.aborted = True
                else:
                    self.aborted = False


    def loop(self):
        cnt = 0

        while cnt < 40:
            if self.aborted:
                while self.aborted:
                    print "waiting"
                    time.sleep(.1)
            print cnt
            cnt += 1
            time.sleep(.1)


class fakeListener():

    def __init__(self):
        listener = threading.Thread(target=self.listener)
        listener.setDaemon(True)
        listener.start()

    def listener(self):
        while True:
            q.put(2)
            time.sleep(1)



if __name__ == '__main__':

    #fake listener standing in for the real OSC event listener
    listener = fakeListener()

    loop = Loop()

Answer 1

Umm.. I don’t completely understand your question but i’ll do my best to explain what I think you need to fix your problems.

1) The thread of your Loop.loop function should be set as a daemon thread so that it exits with your main thread (so you don’t have to kill the python process every time you want to shut down your program). To do this just put loop.setDaemon(True) before you call the thread’s “start” function.

2)The most simple and fail-proof way to communicate between threads is with a Queue. On thread will put an item in that Queue and another thread will take an item out, do something with the item and then terminate (or get another job)

In python a Queue can be anything from a global list to python’s built-in Queue object. I recommend the python Queue because it is thread safe and easy to use.