So as presaged, this is a schematic of how I've implemented "wait for signal or timeout". First, I have a "PermaShred" class: a call to: PermaShred.run_process(this); calls a do_process() function (which you subclass) in its own thread, er, shred. When your do_process() function returns, the shred is returned to a resource pool, making it available to the next call to PermaShred.run_process(). That's my basic mechanism for not leaking shreds. To build wait_for_signal_or_timeout(event E, time T) functionality, I spawn, er, spork a PermaShred "watchdog" that waits until time T arrives, and then does a E.broadcast(). In the meantime, the caller simply blocks on event E. As a result, the caller will return if anyone does a broadcast on E OR if the watchdog process times out. It's a bit convoluted -- among other nuances, the watchdog shred needs to be careful about signaling after the caller has moved on -- but it does the job. And it doesn't leak memory after an initial pool of PermaShred objects have been allocated. If anyone wants to see the code, let me know. - Rob