concurrency via message queues: how to avoid recursion?

I am working on a concurrency system based on message queues with an underlying thread pool. A queue can target other queues. Also a queue can be targeted by multiple queues (i.e. children) to create a tree hierarchy and to prioritise some of the queues.

I want to avoid signalling threads each time a message is queued while the queue (and its children) is (are) already being drained.

So the queue knows if it's sleeping or running. Transition from sleeping to running is easy. That can be done when a new message is queued.

I am more concerned about the other way around. How can I avoid missing messages/events when I transition from running to sleeping? To clarify: this is not an atomic step. The queue also can't go to sleep when its children still need attention.

At the moment in the sleep function I set the state to sleeping, then check if the current queue or its children have any pending events that were missed. If so, I wake the queue back up. But doesn't that potentially cause an infinite recursion of awake - sleep - awake - sleep - ... ?

How can I avoid this, or what's the proper way to setup such a queue system?

In pseudo code:

atomic state = sleeping target = anotherQueue children = queues that target this queue func Async(event) { get lock push event onto queue (i.e. array/fifo/...) release lock this.wakeup() } func wakeup() { If (state == running) { return } state = running !target ? drain() : target.wakeup() } func drain() { while (event = next() ) { event.run() } sleep() } func sleep() { state = sleeping *** what if an event is posted during the transition from running to sleeping? *** //check if events have been missed If (event.count > 0) { this.wakeup() } //check children: don't sleep if they have pending events If (children.haveEvents) { this.wakeup } } func next() { get lock nextEvent = pop event from queue release lock If (!nextEvent) { //check each child queue for an event children.nextEvent } return nextEvent }