帮我用C++写一个多线程编程中的读者和写者问题

好的，下面是一个简单的读者和写者问题的代码实现，使用了C++11的线程库：

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

using namespace std;

// 读者写者问题中的共享资源
int shared_data = 0;

// 读者写者问题中的互斥锁
mutex mtx;

// 读者写者问题中的条件变量
condition_variable cv;

// 读者数量
int reader_num = 0;

// 写者数量
int writer_num = 0;

// 读者线程函数
void reader_func(int id)
{
    while (true)
    {
        // 等待互斥锁
        unique_lock<mutex> lck(mtx);

        // 等待写者释放资源
        while (writer_num > 0)
        {
            cv.wait(lck);
        }

        // 读者数量加1
        reader_num++;

        // 释放互斥锁
        lck.unlock();

        // 读取共享资源
        cout << "Reader " << id << " read shared_data: " << shared_data << endl;

        // 等待一段时间
        this_thread::sleep_for(chrono::milliseconds(500));

        // 等待互斥锁
        lck.lock();

        // 读者数量减1
        reader_num--;

        // 如果没有读者了，唤醒所有写者
        if (reader_num == 0)
        {
            cv.notify_all();
        }

        // 释放互斥锁
        lck.unlock();

        // 等待一段时间
        this_thread::sleep_for(chrono::milliseconds(500));
    }
}

// 写者线程函数
void writer_func(int id)
{
    while (true)
    {
        // 等待互斥锁
        unique_lock<mutex> lck(mtx);

        // 等待读者和写者都释放资源
        while (reader_num > 0 || writer_num > 0)
        {
            cv.wait(lck);
        }

        // 写者数量加1
        writer_num++;

        // 释放互斥锁
        lck.unlock();

        // 写入共享资源
        shared_data++;

        cout << "Writer " << id << " write shared_data: " << shared_data << endl;

        // 等待一段时间
        this_thread::sleep_for(chrono::milliseconds(500));

        // 等待互斥锁
        lck.lock();

        // 写者数量减1
        writer_num--;

        // 唤醒所有读者和写者
        cv.notify_all();

        // 释放互斥锁
        lck.unlock();

        // 等待一段时间
        this_thread::sleep_for(chrono::milliseconds(500));
    }
}

int main()
{
    // 创建3个读者线程
    thread reader1(reader_func, 1);
    thread reader2(reader_func, 2);
    thread reader3(reader_func, 3);

    // 创建2个写者线程
    thread writer1(writer_func, 1);
    thread writer2(writer_func, 2);

    // 等待所有线程结束
    reader1.join();
    reader2.join();
    reader3.join();
    writer1.join();
    writer2.join();

    return 0;
}

在上面的代码中，我们使用了一个互斥锁来保护共享资源，同时使用了一个条件变量来协调读者和写者的访问。当有读者访问共享资源时，读者数量加1，当读者数量为0时，唤醒所有等待的写者；当有写者访问共享资源时，写者数量加1，等待所有的读者和写者都释放资源后，写入共享资源并唤醒所有等待的读者和写者。