在linux环境下编写c++应用程序，该程序运行时能创建N个线程，其中既有读者线程又有写者线程，它们按照事先设计好的测试数据进行读写操作。用信号量和PV操作实现读者/写者问题。

读者/写者问题是一个经典的并发控制问题，其中多个读者和写者共享同一资源（如文件、数据库等），但是读写操作不可同时进行。读者线程可以同时进行读操作，但是写者线程必须独占地进行写操作。

在Linux下，可以使用信号量和PV操作来实现读者/写者问题的解决方案。下面是一个使用信号量和PV操作实现读者/写者问题的示例代码，其中使用了互斥信号量（mutex）和读写信号量（rw）：

#include <pthread.h>
#include <semaphore.h>
#include <iostream>

using namespace std;

#define N 10 // 读者/写者数量

int read_count = 0; // 当前正在读取的读者数量
char data = 'A'; // 共享数据
sem_t mutex, rw; // 互斥信号量和读写信号量

void *reader(void *arg)
{
    int id = *(int *)arg;

    while (1) {
        // 进入临界区
        sem_wait(&mutex);
        read_count++;
        if (read_count == 1) {
            sem_wait(&rw);
        }
        sem_post(&mutex);

        // 读取共享数据
        cout << "Reader " << id << " read data: " << data << endl;

        // 离开临界区
        sem_wait(&mutex);
        read_count--;
        if (read_count == 0) {
            sem_post(&rw);
        }
        sem_post(&mutex);

        sleep(1); // 休眠1秒
    }
}

void *writer(void *arg)
{
    int id = *(int *)arg;

    while (1) {
        // 进入临界区
        sem_wait(&rw);

        // 写入共享数据
        data++;
        cout << "Writer " << id << " write data: " << data << endl;

        // 离开临界区
        sem_post(&rw);

        sleep(1); // 休眠1秒
    }
}

int main()
{
    pthread_t readers[N], writers[N];
    int reader_arg[N], writer_arg[N];

    // 初始化信号量
    sem_init(&mutex, 0, 1);
    sem_init(&rw, 0, 1);

    // 创建读者和写者线程
    for (int i = 0; i < N; i++) {
        reader_arg[i] = i;
        writer_arg[i] = i;
        pthread_create(&readers[i], NULL, reader, &reader_arg[i]);
        pthread_create(&writers[i], NULL, writer, &writer_arg[i]);
    }

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

    // 销毁信号量
    sem_destroy(&mutex);
    sem_destroy(&rw);

    return 0;
}

在上面的代码中，我们首先定义了读者线程和写者线程的函数，其中读者线程首先获取互斥信号量，然后将读者数量加1，如果是第一个读者，则获取读写信号量。读者线程读取共享数据后，再次获取互斥信号量，将读者数量减1，如果是最后一个读者，则释放读写信号量。写者线程首先获取读写信号量，然后写入共享数据后释放读写信号量。

在main函数中，我们初始化互斥信号量和读写信号量，然后创建读者线程和写者线程，并等待所有线程结束后销毁信号量。

注意：由于Linux下的信号量操作是原子操作，因此可以保证信号量的正确性。但是，在实际应用中，需要注意如下几个问题：

- 读者优先或写者优先：在上面的代码中，读者和写者的访问是公平的，但是实际应用中，可能需要考虑读者优先或写者优先。
- 饥饿问题：如果读者和写者同时有大量等待，则可能会导致某些线程饥饿。可以通过引入优先级来解决饥饿问题。
- 死锁问题：如果某个线程获取了互斥信号量但是未释放，将会导致死锁。可以通过引入超时机制或死锁检测机制来解决死锁问题。