下面是一个使用C++11标准的读写锁的例子：

//c++
#include <iostream>
#include <thread>
#include <mutex>
#include <shared_mutex>

std::shared_mutex rw_mutex; // 读写锁

void read_data(int id) {
    std::shared_lock<std::shared_mutex> lock(rw_mutex); // 读锁
    std::cout << "Reader " << id << " is reading data." << std::endl;
    // 读取数据的操作
}

void write_data(int id) {
    std::unique_lock<std::shared_mutex> lock(rw_mutex); // 写锁
    std::cout << "Writer " << id << " is writing data." << std::endl;
    // 写入数据的操作
}

int main() {
    std::thread readers[5];
    std::thread writers[2];

    // 创建5个读者线程
    for (int i = 0; i < 5; ++i) {
        readers[i] = std::thread(read_data, i);
    }

    // 创建2个写者线程
    for (int i = 0; i < 2; ++i) {
        writers[i] = std::thread(write_data, i);
    }

    // 等待所有线程执行完毕
    for (int i = 0; i < 5; ++i) {
        readers[i].join();
    }
    for (int i = 0; i < 2; ++i) {
        writers[i].join();
    }

    return 0;
}
```

//在上面的例子中，我们使用了`std::shared_mutex`类来实现读写锁。读者线程使用 

//`std::shared_lock`类来获取读锁，写者线程使用`std::unique_lock`类来获取写锁。
//在读锁被持有时，其他读者线程可以同时获取读锁，但写者线程必须等待读锁被释放。在写锁被

//持有时，其他读者线程和写者线程都必须等待写锁被释放。