This sounds rather similar to the "leader / followers" pattern that came out of ACE back in the CORBA era of the late '90s [1]:<p>> Structure a pool of threads to share a set of event sources efficiently by taking turns demultiplexing events that arrive on these event sources and synchronously dispatching the events to application services that process them.<p>> In detail: design a thread pool mechanism that allows multiple threads to coordinate themselves and protect critical sections while detecting, demultiplexing, dispatching, and processing events. In this mechanism, allow one thread at a time - the leader - to wait for an event to occur from a set of event sources. Meanwhile, other threads - the followers - can queue up waiting their turn to become the leader. After the current leader thread detects an event from the event source set, it first promotes a follower thread to become the new leader. It then plays the role of a processing thread, which demultiplexes and dispatches the event to a designated event handler that performs application-specific event handling in the processing thread. Multiple processing threads can handle events concurrently while the current leader thread waits for new events on the set of event sources shared by the threads. After handling its event, a processing thread reverts to a follower role and waits to become the leader thread again.<p>The 'Known Uses' section in the paper is fun.<p>[1] Leader/Followers: A Design Pattern for Efficient Multi-threaded Event Demultiplexing and Dispatching - D. C. Schmidt, C. O'Ryan, I. Pyarali, M. Kircher, F. Buschmann; Proceedings of the 7th Pattern Languages of Programs Conference (August 2000) <a href="https://www.dre.vanderbilt.edu/~schmidt/PDF/lf.pdf" rel="nofollow">https://www.dre.vanderbilt.edu/~schmidt/PDF/lf.pdf</a>