C Programming: pthread_cond_wait()

Welcome to our comprehensive guide on pthread_cond_wait() in C programming! This tutorial is designed to help both beginners and intermediates understand and apply this powerful function in your projects. Let's dive in! 🎯

Understanding pthread_cond_wait()

pthread_cond_wait() is a function used in C programming for synchronizing threads. It is part of the POSIX threads (pthreads) library, allowing multiple threads to wait for a specific condition to become true. 📝

Prerequisites

Before we delve into the details, it's essential to have a basic understanding of the following:

pthread_cond_wait() Syntax

The syntax for pthread_cond_wait() is:

int pthread_cond_wait(pthread_cond_t *restrict condition, pthread_mutex_t *restrict mutex);

condition: The condition variable that the thread is waiting for.
mutex: A mutex associated with the condition variable.

How pthread_cond_wait() Works

A thread calls pthread_cond_wait(), indicating it is waiting for a specific condition to be true.
The thread releases the mutex associated with the condition variable.
When the condition becomes true, another thread notifies the waiting thread, and it is awakened.
Upon awakening, the thread re-acquires the mutex.

💡 Pro Tip: Remember, a thread can only wait on a condition variable that is associated with the same mutex it is currently holding.

Example 1: Simple Producer-Consumer Problem

Here's a simple example of the producer-consumer problem using pthread_cond_wait().

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

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int buffer = 0;
int items = 0;

void *producer(void *arg) {
    // Producer code
}

void *consumer(void *arg) {
    // Consumer code
}

int main() {
    pthread_t producer_thread, consumer_thread;

    pthread_create(&producer_thread, NULL, producer, NULL);
    pthread_create(&consumer_thread, NULL, consumer, NULL);

    pthread_join(producer_thread, NULL);
    pthread_join(consumer_thread, NULL);

    return 0;
}

In this example, the producer and consumer threads use the shared buffer variable and the condition variable cond to synchronize their access.

Example 2: Rate-Limiting HTTP Requests

In real-world scenarios, pthread_cond_wait() can be used for rate-limiting HTTP requests.

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

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int requests = 0;
int rate_limit = 10; // Limit to 10 requests per second

void *handle_request(void *arg) {
    pthread_mutex_lock(&mutex);
    while (requests >= rate_limit) {
        pthread_cond_wait(&cond, &mutex);
    }
    requests++;
    // Handle the request here
    sleep(1);
    requests--;
    pthread_mutex_unlock(&mutex);
    pthread_cond_signal(&cond);
    return NULL;
}

int main() {
    pthread_t threads[100];

    for (int i = 0; i < 100; i++) {
        pthread_create(&threads[i], NULL, handle_request, NULL);
    }

    for (int i = 0; i < 100; i++) {
        pthread_join(threads[i], NULL);
    }

    return 0;
}

In this example, we limit the number of concurrent HTTP requests by using pthread_cond_wait() to wait when the rate limit is reached.

Quiz

That's all for our comprehensive guide on pthread_cond_wait() in C programming! As you progress, remember to practice and experiment with these concepts to strengthen your understanding. 💡 Happy coding!