Question

I have a list in my python program that gets new items on certain occasions (It’s a message-queue consumer). Then I have a thread that every few minutes checks to see if there’s anything in the list, and if there is then I want to do an action on each item and then empty the list.

Now my problem: should I use locks to ensure that the action in the subthread is atomic, and does this ensure that the main thread can’t alter the list while I’m going through the list?
Or should I instead use some kind of flag?

Pseudocode to make my problem clearer.

Subthread:

def run(self):
    while 1:
        if get_main_thread_list() is not empty:
            do_operations()
        empty_the_list()
        sleep(30)

Main thread:

list = []

def on_event(item):
    list.add(item)

def main():
    start_thread()
    start_listening_to_events()

I hope this makes my problem clearer, and any links to resources or comments are obviously welcome!

PS: I’m well aware that I just might not grasp threaded programming well enough for this question, if you believe so could you please take some time explaining whats wrong with my reasoning if you have the time.

Answer 1

should I use locks to ensure that the action in the subthread is atomic, and does this ensure that the main thread can’t alter the list while I’m going through the list?

Yes. If you implement it correctly yes.

Or should I instead use some kind of flag?

“some kind of flag” == lock, so you’d better use threading locks.

Important: It looks to me like you’re trying to reimplement the queue module from the stdlib, you might want to take a look at it.

Other than having a bunch of interesting features is also thread safe:

The queue module implements multi-producer, multi-consumer queues. It is especially useful in threaded programming when information must be exchanged safely between multiple threads. The Queue class in this module implements all the required locking semantics.