Design Bounded Blocking Queue - Practice Coding Problems

Design Bounded Blocking Queue - Problem

Concurrency Medium

Design and implement a thread-safe bounded blocking queue that efficiently handles concurrent access from multiple producer and consumer threads.

Your queue should support the following operations:

BoundedBlockingQueue(int capacity) - Initialize the queue with a maximum capacity
void enqueue(int element) - Add an element to the rear of the queue. If the queue is full, the calling thread should block until space becomes available
int dequeue() - Remove and return the element from the front of the queue. If the queue is empty, the calling thread should block until an element becomes available
int size() - Return the current number of elements in the queue

Key Requirements:

The implementation must be thread-safe and handle concurrent access properly
Producer threads will only call enqueue()
Consumer threads will only call dequeue()
Blocking behavior is essential - threads must wait when the queue is full/empty
Do not use built-in blocking queue implementations

This is a fundamental concurrency problem that tests your understanding of synchronization primitives like locks, condition variables, and thread coordination.

Input & Output

example_1.py — Basic Operations

$ Input: capacity = 3 operations: [enqueue(1), enqueue(2), size(), dequeue(), size()]

› Output: [null, null, 2, 1, 1]

💡 Note: Create queue with capacity 3, add elements 1 and 2 (size becomes 2), remove element 1 from front (size becomes 1). Operations execute without blocking since queue is neither full nor empty.

example_2.py — Blocking Behavior

$ Input: capacity = 2 Thread 1: enqueue(1), enqueue(2), enqueue(3) [blocks on third] Thread 2: dequeue() [returns 1, unblocks Thread 1]

› Output: Thread 1 completes enqueue(3), Thread 2 gets 1

💡 Note: Thread 1 fills the queue and blocks on the third enqueue. When Thread 2 dequeues an element, it creates space and Thread 1 can complete its operation.

example_3.py — Empty Queue Blocking

$ Input: capacity = 2 Thread 1: dequeue() [blocks on empty queue] Thread 2: enqueue(5) [unblocks Thread 1]

› Output: Thread 1 gets 5 from dequeue()

💡 Note: Thread 1 tries to dequeue from an empty queue and blocks. When Thread 2 adds element 5, Thread 1 is unblocked and receives that element.

Visualization

Tap to expand

Understanding the Visualization

Setup

Initialize queue with mutex lock and two condition variables: notFull and notEmpty

Producer Waits

When queue is full, producer thread waits on notFull condition variable

Consumer Signals

After dequeue, consumer signals notFull to wake up waiting producers

Consumer Waits

When queue is empty, consumer thread waits on notEmpty condition variable

Producer Signals

After enqueue, producer signals notEmpty to wake up waiting consumers

Key Takeaway

🎯 Key Insight: Condition variables provide the perfect mechanism for thread coordination - they eliminate busy waiting while ensuring threads wake up immediately when their conditions can be satisfied, making the solution both efficient and scalable.

Time & Space Complexity

Time Complexity

⏱️

O(1)

Each operation is O(1) with efficient blocking - no wasted cycles

✓ Linear Growth

Space Complexity

O(n)

Space for queue elements plus small overhead for synchronization primitives

⚡ Linearithmic Space

Constraints

1 ≤ capacity ≤ 10³
0 ≤ element ≤ 10⁶
At most 10⁴ operations will be performed
Must handle concurrent access from multiple threads
Implementation must be thread-safe without using built-in blocking queues

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses condition variables with mutex locks to achieve efficient thread-safe blocking behavior. Key insights: use separate condition variables for 'not full' and 'not empty' states, employ proper predicate loops to handle spurious wakeups, and signal the appropriate condition after each operation. This approach eliminates busy waiting and scales excellently under high concurrency.

Common Approaches

Approach	Time	Space	Notes
✓ Simple Lock with Busy Waiting	O(1)	O(n)	Use a single lock with busy waiting loops for blocking behavior
Condition Variables (Optimal)	O(1)	O(n)	Use condition variables for efficient blocking and signaling between threads

Simple Lock with Busy Waiting — Algorithm Steps

Use a simple array/list as the underlying storage
Protect all operations with a single mutex lock
Implement blocking through while loops that repeatedly check conditions
Use sleep() calls to avoid completely busy waiting
Track current size and capacity manually

Visualization

Tap to expand

Step-by-Step Walkthrough

Thread Attempts Operation

Thread acquires lock and checks if operation is possible

Condition Not Met

If queue is full/empty, thread releases lock and sleeps briefly

Retry Loop

Thread wakes up and repeats the check, potentially many times

Success

Eventually condition is met and operation completes

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>

typedef struct {
    int* queue;
    int capacity;
    int size;
    int front;
    int rear;
    pthread_mutex_t mutex;
} BoundedBlockingQueue;

BoundedBlockingQueue* createQueue(int capacity) {
    BoundedBlockingQueue* bbq = malloc(sizeof(BoundedBlockingQueue));
    bbq->queue = malloc(capacity * sizeof(int));
    bbq->capacity = capacity;
    bbq->size = 0;
    bbq->front = 0;
    bbq->rear = 0;
    pthread_mutex_init(&bbq->mutex, NULL);
    return bbq;
}

void enqueue(BoundedBlockingQueue* bbq, int element) {
    while (1) {
        pthread_mutex_lock(&bbq->mutex);
        if (bbq->size < bbq->capacity) {
            bbq->queue[bbq->rear] = element;
            bbq->rear = (bbq->rear + 1) % bbq->capacity;
            bbq->size++;
            pthread_mutex_unlock(&bbq->mutex);
            return;
        }
        pthread_mutex_unlock(&bbq->mutex);
        usleep(10000); // 10ms
    }
}

int dequeue(BoundedBlockingQueue* bbq) {
    while (1) {
        pthread_mutex_lock(&bbq->mutex);
        if (bbq->size > 0) {
            int element = bbq->queue[bbq->front];
            bbq->front = (bbq->front + 1) % bbq->capacity;
            bbq->size--;
            pthread_mutex_unlock(&bbq->mutex);
            return element;
        }
        pthread_mutex_unlock(&bbq->mutex);
        usleep(10000); // 10ms
    }
}

int size(BoundedBlockingQueue* bbq) {
    pthread_mutex_lock(&bbq->mutex);
    int currentSize = bbq->size;
    pthread_mutex_unlock(&bbq->mutex);
    return currentSize;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Each operation is O(1) but with potential busy waiting overhead

✓ Linear Growth

Space Complexity

O(n)

Space for the queue elements plus minimal overhead

⚡ Linearithmic Space

Constraints

1 ≤ capacity ≤ 10³
0 ≤ element ≤ 10⁶
At most 10⁴ operations will be performed
Must handle concurrent access from multiple threads
Implementation must be thread-safe without using built-in blocking queues

78.0K Views

High Frequency

~35 min Avg. Time

2.9K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Simple Lock with Busy Waiting — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler