c++thread中使用 读写锁

在C语言中，读写锁是一种特殊的锁，可以同时支持多个读操作或单个写操作。在多线程程序中，使用读写锁可以提高程序的并发性能。

以下是使用读写锁的基本步骤：

1. 定义读写锁

pthread_rwlock_t rwlock;

2. 初始化读写锁

pthread_rwlock_init(&rwlock, NULL);

3. 对共享数据进行读操作

pthread_rwlock_rdlock(&rwlock);
// read data
pthread_rwlock_unlock(&rwlock);

4. 对共享数据进行写操作

pthread_rwlock_wrlock(&rwlock);
// write data
pthread_rwlock_unlock(&rwlock);

需要注意的是，当一个线程持有读锁时，其他线程可以同时持有读锁，但不能持有写锁。当一个线程持有写锁时，其他线程不能持有读锁或写锁。

此外，读写锁也支持尝试加锁和超时机制，可以根据具体情况进行设置。

相关问题

c++11 thread中使用 读写锁

C11标准库中提供了读写锁，可以用来实现多个线程对同一资源的并发读写操作。下面是使用读写锁的示例代码：

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

int data = 0;
rwlock_t lock;

int reader(void* arg) {
  int id = *(int*)arg;
  while (1) {
    thrd_sleep((struct timespec){.tv_sec = 1}, NULL); // 模拟读操作
    // 加读锁
    rwlock_rdlock(&lock);
    printf("Reader %d read data: %d\n", id, data);
    // 释放读锁
    rwlock_unlock(&lock);
  }
  return 0;
}

int writer(void* arg) {
  int id = *(int*)arg;
  while (1) {
    thrd_sleep((struct timespec){.tv_sec = 2}, NULL); // 模拟写操作
    // 加写锁
    rwlock_wrlock(&lock);
    data++;
    printf("Writer %d write data: %d\n", id, data);
    // 释放写锁
    rwlock_unlock(&lock);
  }
  return 0;
}

int main(int argc, char const *argv[]) {
  // 初始化读写锁
  rwlock_init(&lock);
  // 创建3个读线程
  thrd_t readers[3];
  int readerIds[3];
  for (int i = 0; i < 3; i++) {
    readerIds[i] = i + 1;
    thrd_create(&readers[i], reader, &readerIds[i]);
  }
  // 创建2个写线程
  thrd_t writers[2];
  int writerIds[2];
  for (int i = 0; i < 2; i++) {
    writerIds[i] = i + 1;
    thrd_create(&writers[i], writer, &writerIds[i]);
  }
  // 等待所有线程结束
  for (int i = 0; i < 3; i++) {
    thrd_join(readers[i], NULL);
  }
  for (int i = 0; i < 2; i++) {
    thrd_join(writers[i], NULL);
  }
  // 销毁读写锁
  rwlock_destroy(&lock);
  return 0;
}

这个示例程序中有3个读线程和2个写线程，读线程每隔1秒钟读一次共享变量data的值，写线程每隔2秒钟写一次共享变量data的值。读线程和写线程之间会相互竞争读写锁，以实现对共享变量的并发访问。

cpp thread中使用 读写锁

在C++中，读写锁是一种线程同步机制，它允许多个线程同时读取共享数据，但是只有一个线程能够写入共享数据。这种机制可以提高并发性能，因为多个线程可以并发地读取数据，而写入数据时只能有一个线程进行，避免了写入竞争的问题。

下面是使用读写锁的示例代码：

#include <iostream>
#include <thread>
#include <mutex>

std::shared_timed_mutex rw_mutex;
int shared_data = 0;

void reader() {
    std::cout << "Reader thread " << std::this_thread::get_id() << " started." << std::endl;
    // 读取共享数据
    {
        std::shared_lock<std::shared_timed_mutex> lock(rw_mutex);
        std::cout << "Reader thread " << std::this_thread::get_id() << " read data: " << shared_data << std::endl;
    }
}

void writer() {
    std::cout << "Writer thread " << std::this_thread::get_id() << " started." << std::endl;
    // 写入共享数据
    {
        std::unique_lock<std::shared_timed_mutex> lock(rw_mutex);
        shared_data++;
        std::cout << "Writer thread " << std::this_thread::get_id() << " wrote data: " << shared_data << std::endl;
    }
}

int main() {
    std::thread t1(reader);
    std::thread t2(reader);
    std::thread t3(reader);
    std::thread t4(writer);
    std::thread t5(writer);

    t1.join();
    t2.join();
    t3.join();
    t4.join();
    t5.join();

    return 0;
}

在上面的示例代码中，我们使用了`std::shared_timed_mutex`类来创建一个读写锁。在读取共享数据时，我们使用了`std::shared_lock`类来获取读取锁，而在写入共享数据时，我们使用了`std::unique_lock`类来获取写入锁。这两个类都是C++11中新增加的类，用于提供线程安全的读写锁机制。

在主函数中，我们创建了3个读取线程和2个写入线程，它们并发地访问了共享数据。由于使用了读写锁，多个读取线程可以同时读取数据，而写入线程则会在获取写入锁后才能进行写入操作。这样可以避免读写竞争问题，提高程序的并发性能。