Design Bounded Blocking Queue

Design Bounded Blocking Queue - Problem

Concurrency Medium

Implement a thread-safe bounded blocking queue that has the following methods:

BoundedBlockingQueue(int capacity) - The constructor initializes the queue with a maximum capacity.
void enqueue(int element) - Adds an element to the front of the queue. If the queue is full, the calling thread is blocked until the queue is no longer full.
int dequeue() - Returns the element at the rear of the queue and removes it. If the queue is empty, the calling thread is blocked until the queue is no longer empty.
int size() - Returns the number of elements currently in the queue.

Your implementation will be tested using multiple threads at the same time. Each thread will either be a producer thread that only makes calls to the enqueue method or a consumer thread that only makes calls to the dequeue method. The size method will be called after every test case.

Please do not use built-in implementations of bounded blocking queue as this will not be accepted in an interview.

Input & Output

Example 1 — Basic Queue Operations

$ Input: operations = ["BoundedBlockingQueue","enqueue","dequeue","dequeue","enqueue","enqueue","enqueue","dequeue","size"], values = [2,1,null,null,0,2,3,null,null]

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

💡 Note: Create queue capacity 2, enqueue 1, dequeue returns 1, dequeue returns 0 (blocks until 0 enqueued), enqueue 0,2,3 (3 blocks until space), dequeue returns 2, size returns 1

Example 2 — Full Queue Blocking

$ Input: operations = ["BoundedBlockingQueue","enqueue","enqueue","size","dequeue"], values = [1,1,2,null,null]

› Output: [1,1]

💡 Note: Create queue capacity 1, enqueue 1 (fills queue), enqueue 2 blocks until space available, size shows 1, dequeue returns 1

Example 3 — Empty Queue Blocking

$ Input: operations = ["BoundedBlockingQueue","dequeue","enqueue","size"], values = [3,null,5,null]

› Output: [5,0]

💡 Note: Create queue capacity 3, dequeue blocks until element available (5), enqueue 5 unblocks dequeue which returns 5, size shows 0

Constraints

1 ≤ capacity ≤ 1000
0 ≤ element ≤ 1000
At most 1000 calls will be made to enqueue, dequeue, and size

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 f Facebook 28

The key insight is to use condition variables for efficient thread synchronization. When the queue is full, producer threads block on a 'not full' condition. When empty, consumer threads block on a 'not empty' condition. Threads are awakened via signals when conditions change. Best approach uses mutex + condition variables. Time: O(1), Space: O(n)

Common Approaches

✓ Busy Waiting with Locks

⏱️ Time: O(1) Space: O(n)

Acquire locks and continuously check if queue has space (enqueue) or elements (dequeue). Release lock briefly between checks to allow other threads to proceed.

Condition Variables with Blocking

⏱️ Time: O(1) Space: O(n)

Use mutex with condition variables to block threads when queue is full/empty. Threads wait on conditions and are notified when state changes, eliminating busy waiting.

Busy Waiting with Locks — Algorithm Steps

Step 1: Acquire lock on queue
Step 2: Check condition in while loop
Step 3: If condition not met, release lock and retry
Step 4: Perform operation when condition met

Visualization

Tap to expand

Step-by-Step Walkthrough

Thread Requests Lock

Thread acquires mutex to check queue state

Check Condition

Verify if operation can proceed (space/elements available)

Wait and Retry

If condition not met, release lock and retry after brief sleep

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

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

BoundedBlockingQueue* createBoundedBlockingQueue(int capacity) {
    BoundedBlockingQueue* bbq = (BoundedBlockingQueue*)malloc(sizeof(BoundedBlockingQueue));
    bbq->capacity = capacity;
    bbq->queue = (int*)malloc(capacity * sizeof(int));
    bbq->size = 0;
    bbq->front = 0;
    bbq->rear = -1;
    return bbq;
}

void enqueue(BoundedBlockingQueue* bbq, int element) {
    if (bbq->size < bbq->capacity) {
        bbq->rear = (bbq->rear + 1) % bbq->capacity;
        bbq->queue[bbq->rear] = element;
        bbq->size++;
    }
}

int dequeue(BoundedBlockingQueue* bbq) {
    if (bbq->size > 0) {
        int result = bbq->queue[bbq->front];
        bbq->front = (bbq->front + 1) % bbq->capacity;
        bbq->size--;
        return result;
    }
    return 0;
}

int getSize(BoundedBlockingQueue* bbq) {
    return bbq->size;
}

int parseNumber(const char* str, int* pos) {
    int result = 0;
    bool negative = false;
    
    while (str[*pos] && (str[*pos] == ' ' || str[*pos] == ',' || str[*pos] == '[')) {
        (*pos)++;
    }
    
    if (str[*pos] == '-') {
        negative = true;
        (*pos)++;
    }
    
    while (str[*pos] >= '0' && str[*pos] <= '9') {
        result = result * 10 + (str[*pos] - '0');
        (*pos)++;
    }
    
    return negative ? -result : result;
}

int main() {
    char line1[1000], line2[1000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    // Parse operations
    char operations[10][50];
    int opCount = 0;
    char* p = line1;
    while (*p) {
        if (*p == '"') {
            p++;
            int j = 0;
            while (*p != '"' && *p) {
                operations[opCount][j++] = *p++;
            }
            operations[opCount][j] = '\0';
            opCount++;
        }
        p++;
    }
    
    // Parse values
    int values[10];
    int valueCount = 0;
    int pos = 0;
    p = line2;
    while (*p) {
        if (*p >= '0' && *p <= '9' || *p == '-') {
            values[valueCount++] = parseNumber(line2, &pos);
            p = line2 + pos;
        } else if (strncmp(p, "null", 4) == 0) {
            values[valueCount++] = 0;
            p += 4;
        } else {
            p++;
        }
    }
    
    // Execute operations
    BoundedBlockingQueue* bbq = NULL;
    int results[10];
    int resultCount = 0;
    
    for (int i = 0; i < opCount; i++) {
        if (strcmp(operations[i], "BoundedBlockingQueue") == 0) {
            bbq = createBoundedBlockingQueue(values[i]);
        } else if (strcmp(operations[i], "enqueue") == 0) {
            enqueue(bbq, values[i]);
        } else if (strcmp(operations[i], "dequeue") == 0) {
            results[resultCount++] = dequeue(bbq);
        } else if (strcmp(operations[i], "size") == 0) {
            results[resultCount++] = getSize(bbq);
        }
    }
    
    // Print results
    printf("[");
    for (int i = 0; i < resultCount; i++) {
        if (i > 0) printf(",");
        printf("%d", results[i]);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

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

✓ Linear Growth

Space Complexity

O(n)

Queue stores up to n elements plus synchronization overhead

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~25 min Avg. Time

892 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

Constraints

Visualization

Related Problems

Common Approaches

Busy Waiting with Locks — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler