Read-Write Lock - Problem

Implement a read-write lock that allows multiple concurrent readers but exclusive writers. The lock should provide the following functionality:

• Reader Lock: Multiple threads can acquire reader locks simultaneously as long as no writer lock is held

• Writer Lock: Only one thread can acquire a writer lock, and no reader locks can be held while a writer lock is active

• Fair Scheduling: Prevent writer starvation by ensuring waiting writers get priority over new readers

Your implementation should handle concurrent access from multiple threads and provide acquire_read(), release_read(), acquire_write(), and release_write() methods.

Input & Output

Example 1 — Basic Read-Write Operations

$ Input: operations = ["acquire_read", "acquire_read", "acquire_write", "release_read", "release_read"]

› Output: [true,true,false,true,true]

💡 Note: Two readers acquire successfully, writer fails due to active readers, then readers release successfully

Example 2 — Writer Priority

$ Input: operations = ["acquire_write", "acquire_read", "release_write", "acquire_read"]

› Output: [true,false,true,true]

💡 Note: Writer acquires exclusively, reader blocked, writer releases, then reader can acquire

Example 3 — Multiple Operations

$ Input: operations = ["acquire_read", "acquire_read", "release_read", "acquire_write", "release_read", "release_write"]

› Output: [true,true,true,false,true,true]

💡 Note: Multiple readers work concurrently, writer waits for all readers to finish

Constraints

1 ≤ operations.length ≤ 1000
operations[i] is one of "acquire_read", "release_read", "acquire_write", "release_write"
Each release operation has a corresponding acquire operation
No more than 100 concurrent readers or writers

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 28 M Microsoft 22 🍎 Apple 18

The key insight is implementing separate reader counters and writer priority flags to maximize concurrency while preventing starvation. The optimal approach uses priority queues and fairness policies to ensure writers get exclusive access when needed while allowing multiple readers to proceed concurrently. Time: O(1) per operation, Space: O(n) for queue management.

Common Approaches

✓ Fair Read-Write Lock with Priority Queue

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

Implement separate waiting queues for readers and writers with a priority system that prevents starvation. Writers get priority over new readers, but existing readers can complete their operations.

Single Global Lock

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

Every read or write operation must acquire the same global lock, ensuring only one thread can access the resource at any time. This is simple but inefficient since multiple readers could safely operate concurrently.

Fair Read-Write Lock with Priority Queue — Algorithm Steps

Check current lock state and queues
Add request to appropriate priority queue
Process queue based on fairness policy
Grant lock and update state

Visualization

Tap to expand

Step-by-Step Walkthrough

Priority Check

Examine writer priority and queue states

Queue Management

Add requests to appropriate priority queues

Fair Scheduling

Grant access based on fairness policy

Code -

solution.c — C

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

typedef struct QueueNode {
    int data;
    struct QueueNode* next;
} QueueNode;

typedef struct {
    QueueNode* front;
    QueueNode* rear;
    int size;
} Queue;

typedef struct {
    int readers;
    bool writerActive;
    bool writerPriority;
    Queue* readerQueue;
    Queue* writerQueue;
    pthread_mutex_t mutex;
    pthread_cond_t readCond;
    pthread_cond_t writeCond;
} ReadWriteLock;

Queue* createQueue() {
    Queue* q = malloc(sizeof(Queue));
    q->front = q->rear = NULL;
    q->size = 0;
    return q;
}

void enqueue(Queue* q, int data) {
    QueueNode* newNode = malloc(sizeof(QueueNode));
    newNode->data = data;
    newNode->next = NULL;
    if (q->rear == NULL) {
        q->front = q->rear = newNode;
    } else {
        q->rear->next = newNode;
        q->rear = newNode;
    }
    q->size++;
}

int dequeue(Queue* q) {
    if (q->front == NULL) return -1;
    QueueNode* temp = q->front;
    int data = temp->data;
    q->front = q->front->next;
    if (q->front == NULL) q->rear = NULL;
    free(temp);
    q->size--;
    return data;
}

ReadWriteLock* createLock() {
    ReadWriteLock* rwl = malloc(sizeof(ReadWriteLock));
    rwl->readers = 0;
    rwl->writerActive = false;
    rwl->writerPriority = false;
    rwl->readerQueue = createQueue();
    rwl->writerQueue = createQueue();
    pthread_mutex_init(&rwl->mutex, NULL);
    pthread_cond_init(&rwl->readCond, NULL);
    pthread_cond_init(&rwl->writeCond, NULL);
    return rwl;
}

bool acquireRead(ReadWriteLock* rwl) {
    pthread_mutex_lock(&rwl->mutex);
    if (rwl->writerActive || rwl->writerPriority || rwl->writerQueue->size > 0) {
        pthread_mutex_unlock(&rwl->mutex);
        return false;
    }
    rwl->readers++;
    pthread_mutex_unlock(&rwl->mutex);
    return true;
}

bool releaseRead(ReadWriteLock* rwl) {
    pthread_mutex_lock(&rwl->mutex);
    rwl->readers--;
    if (rwl->readers == 0 && rwl->writerQueue->size > 0) {
        rwl->writerPriority = true;
        pthread_cond_signal(&rwl->writeCond);
    }
    pthread_mutex_unlock(&rwl->mutex);
    return true;
}

bool acquireWrite(ReadWriteLock* rwl) {
    pthread_mutex_lock(&rwl->mutex);
    if (rwl->readers > 0 || rwl->writerActive) {
        rwl->writerPriority = true;
        enqueue(rwl->writerQueue, 1);
        pthread_mutex_unlock(&rwl->mutex);
        return false;
    }
    rwl->writerActive = true;
    rwl->writerPriority = false;
    pthread_mutex_unlock(&rwl->mutex);
    return true;
}

bool releaseWrite(ReadWriteLock* rwl) {
    pthread_mutex_lock(&rwl->mutex);
    rwl->writerActive = false;
    rwl->writerPriority = false;
    if (rwl->writerQueue->size > 0) {
        dequeue(rwl->writerQueue);
        pthread_cond_signal(&rwl->writeCond);
    } else {
        pthread_cond_broadcast(&rwl->readCond);
    }
    pthread_mutex_unlock(&rwl->mutex);
    return true;
}

int* solution(char operations[][20], int size, int* returnSize) {
    ReadWriteLock* rwlock = createLock();
    int* results = malloc(size * sizeof(int));
    *returnSize = size;
    
    for (int i = 0; i < size; i++) {
        if (strcmp(operations[i], "acquire_read") == 0) {
            results[i] = acquireRead(rwlock) ? 1 : 0;
        } else if (strcmp(operations[i], "release_read") == 0) {
            results[i] = releaseRead(rwlock) ? 1 : 0;
        } else if (strcmp(operations[i], "acquire_write") == 0) {
            results[i] = acquireWrite(rwlock) ? 1 : 0;
        } else if (strcmp(operations[i], "release_write") == 0) {
            results[i] = releaseWrite(rwlock) ? 1 : 0;
        }
    }
    
    return results;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    char operations[100][20];
    int count = 0;
    
    char* token = strtok(line, "[],\"");
    while (token != NULL && count < 100) {
        if (strlen(token) > 0 && strcmp(token, " ") != 0) {
            strcpy(operations[count], token);
            count++;
        }
        token = strtok(NULL, "[],\"");
    }
    
    int returnSize;
    int* result = solution(operations, count, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%s", result[i] ? "true" : "false");
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Queue operations and lock state updates are constant time

✓ Linear Growth

Space Complexity

O(n)

Requires queues to store waiting readers and writers

✓ Linear Space

31.2K Views

Medium Frequency

~35 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

Read-Write Lock - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Fair Read-Write Lock with Priority Queue — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler