SynchronousQueue

SynchronousQueue is a specialized blocking queue in the Java standard library that has no internal capacity. It is designed for direct handoff of elements between producer and consumer threads: each insertion by a producer must wait for a corresponding removal by a consumer, and each removal must wait for a corresponding insertion. In practice, an item is transferred directly from the thread offering it to the thread taking it, with no buffering.

The queue supports the standard BlockingQueue operations: put and take, which block indefinitely until a counterpart is available, and offer and poll with timeouts, which can fail after a specified duration. A key behavioral detail is that the size of a SynchronousQueue is always zero; there is no capacity to store elements between producers and consumers. The queue can be configured as fair or non-fair via its constructors: SynchronousQueue() creates a non-fair queue, while SynchronousQueue(boolean fair) creates a queue with a specified fairness policy. In a fair queue, waiting producers and consumers are served in FIFO order; in a non-fair queue, transfers may occur as soon as a thread is ready, potentially out of order for higher throughput.

Common uses include direct handoffs in thread pools and other scenarios where tasks should be handed off directly to worker threads without buffering. It is well suited for rendezvous patterns and latency-sensitive transfers where temporary storage would be undesirable. Because of its zero-capacity design, SynchronousQueue is not appropriate when buffering or decoupling between producers and consumers is required; in such cases, other queue implementations with capacity, such as LinkedBlockingQueue, are used.