pthread_mutex_lock(&mutex); readers_count--; if (readers_count == 0) { // 最后一个读者退出时，需要释放共享资源 printf("读取器%d已退出并解锁资源。\n", id); } pthread_mutex_unlock(&mutex); // 等待下一次读取操作 sleep(rand() % 5); }

这段代码看起来像是一个读写锁的实现，其中mutex是一个互斥锁，readers_count是一个表示读者数量的计数器。当一个读者进入临界区时，它会先获取互斥锁，然后将读者计数器加1，最后释放互斥锁。当最后一个读者退出时，它会检查读者计数器是否为0，如果是，则释放共享资源。这段代码也包含了一个随机的睡眠时间，用于模拟读者的读取操作。

相关问题

void *reader(void *arg) { int id = *((int *)arg); while (1) { pthread_mutex_lock(&mutex); readers_count++; if (readers_count == 1) { // 第一个读者进入，需要占据共享资源 printf("读取器%d已输入并锁定了资源。\n", id); } pthread_mutex_unlock(&mutex); // 读取共享资源，这里用 sleep 模拟读取操作 printf("Reader%d正在读取资源。\n", id); sleep(1); pthread_mutex_lock(&mutex); readers_count--; if (readers_count == 0) { // 最后一个读者退出时，需要释放共享资源 printf("读取器%d已退出并解锁资源。\n", id); } pthread_mutex_unlock(&mutex); // 等待下一次读取操作 sleep(rand() % 5); } }

这段代码是一个读者优先的读写锁实现，它使用了 pthread 库中的互斥锁（mutex）来保证并发访问共享资源的正确性。在读取操作开始之前，读者线程需要先获取互斥锁，然后递增读者数量，如果这是第一个读者线程，它将占据共享资源，并打印一条信息。在读取操作结束之后，读者线程需要先获取互斥锁，然后递减读者数量，如果这是最后一个读者线程，它将释放共享资源，并打印一条信息。这个实现的特点是，当有读者正在读取时，写者需要等待所有读者读取结束后才能开始写入。

编程实现经典的进程同步问题--读者与写者问题。

以下是一个基于互斥锁和条件变量的 C 语言代码实现，用于解决经典的读者写者问题：

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

#define BUFFER_SIZE 1024  // 缓冲区大小
#define READ_COUNT 10     // 读取次数
#define WRITE_COUNT 5     // 写入次数

// 全局变量定义
char buffer[BUFFER_SIZE];  // 缓冲区
int read_count = 0;        // 当前读者数量
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;      // 互斥锁
pthread_cond_t read_cond = PTHREAD_COND_INITIALIZER;   // 读条件变量
pthread_cond_t write_cond = PTHREAD_COND_INITIALIZER;  // 写条件变量

// 读者线程函数
void *reader(void *arg) {
    int i;
    for (i = 0; i < READ_COUNT; i++) {
        pthread_mutex_lock(&mutex);     // 加锁

        // 等待写者释放锁
        while (buffer[0] == '\0') {
            pthread_cond_wait(&read_cond, &mutex);
        }

        // 读取缓冲区内容
        printf("Reader %ld start reading: %s\n", (long)arg, buffer);

        // 读者数量加一
        read_count++;

        // 唤醒其他读者
        pthread_cond_broadcast(&read_cond);

        pthread_mutex_unlock(&mutex);   // 解锁
    }

    pthread_exit(NULL);
}

// 写者线程函数
void *writer(void *arg) {
    int i;
    for (i = 0; i < WRITE_COUNT; i++) {
        pthread_mutex_lock(&mutex);     // 加锁

        // 等待读者释放锁
        while (read_count > 0) {
            pthread_cond_wait(&write_cond, &mutex);
        }

        // 写入缓冲区内容
        sprintf(buffer, "Writer %ld wrote a message.", (long)arg);
        printf("Writer %ld wrote: %s\n", (long)arg, buffer);

        // 唤醒其他等待的线程
        pthread_cond_broadcast(&write_cond);
        pthread_cond_broadcast(&read_cond);

        pthread_mutex_unlock(&mutex);   // 解锁
    }

    pthread_exit(NULL);
}

int main() {
    pthread_t readers[3], writers[2];   // 创建3个读者线程和2个写者线程
    int i;

    // 创建读者线程
    for (i = 0; i < 3; i++) {
        pthread_create(&readers[i], NULL, reader, (void *)(long)i);
    }

    // 创建写者线程
    for (i = 0; i < 2; i++) {
        pthread_create(&writers[i], NULL, writer, (void *)(long)i);
    }

    // 等待所有线程结束
    for (i = 0; i < 3; i++) {
        pthread_join(readers[i], NULL);
    }
    for (i = 0; i < 2; i++) {
        pthread_join(writers[i], NULL);
    }

    return 0;
}

在这个例子中，我们通过创建3个读者线程和2个写者线程来模拟读者写者问题。当有读者正在读取资源时，写者必须等待读者全部释放锁才能写入资源。当有写者正在写入资源时，所有读者必须等待写者释放锁才能读取资源。通过互斥锁和条件变量的配合，可以实现读者写者问题的安全同步。