consumerproducer

Producer–consumer, also known as the consumer–producer problem or the bounded-buffer problem, is a classical synchronization problem in concurrent programming. It involves two kinds of threads: producers that generate data items and place them into a shared, finite buffer, and consumers that remove items from the buffer for processing. The objective is to coordinate access so that producers never add items when the buffer is full, and consumers never remove items when it is empty, while ensuring mutual exclusion during buffer updates.

In a typical solution, the shared buffer is implemented as a fixed-size circular queue. Synchronization is provided by primitives such as semaphores, mutexes, condition variables, or monitors. A common pattern uses three controls: a mutex to ensure exclusive access to the buffer, and two counting semaphores named empty and full that track available and filled slots. A producer waits on empty, acquires the mutex to add an item, releases the mutex, and signals full. A consumer waits on full, acquires the mutex to remove an item, releases the mutex, and signals empty. This arrangement prevents race conditions and overrun or underrun of the buffer.

Extensions include multiple producers and consumers, unbounded buffers (which remove the full constraint but can risk memory growth), and more complex pipeline architectures. In modern systems, similar problems are solved with blocking queues, channels (as in certain programming languages), or message-passing frameworks.

See also: bounded-buffer problem, inter-thread communication, producer–consumer pattern.