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

好的，这是一个经典的读者/写者问题。下面是一个示例代码，使用信号量和PV操作实现读者/写者问题。

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

#define N 100
#define READERS 5
#define WRITERS 5

int data = 0;
int readers_count = 0;
sem_t mutex, resource, readers;

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

    while (1) {
        sem_wait(&resource);
        data++;
        printf("Writer %d writes data %d\n", id, data);
        sem_post(&resource);

        sleep(1);
    }
}

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

    while (1) {
        sem_wait(&readers);
        sem_wait(&mutex);
        readers_count++;
        if (readers_count == 1) {
            sem_wait(&resource);
        }
        sem_post(&mutex);
        sem_post(&readers);

        printf("Reader %d reads data %d\n", id, data);

        sem_wait(&mutex);
        readers_count--;
        if (readers_count == 0) {
            sem_post(&resource);
        }
        sem_post(&mutex);

        sleep(1);
    }
}

int main() {
    pthread_t threads[N];
    sem_init(&mutex, 0, 1);
    sem_init(&resource, 0, 1);
    sem_init(&readers, 0, READERS);

    for (int i = 0; i < READERS; i++) {
        int *arg = malloc(sizeof(int));
        *arg = i;
        pthread_create(&threads[i], NULL, reader, arg);
    }
    for (int i = READERS; i < READERS + WRITERS; i++) {
        int *arg = malloc(sizeof(int));
        *arg = i;
        pthread_create(&threads[i], NULL, writer, arg);
    }
    for (int i = 0; i < READERS + WRITERS; i++) {
        pthread_join(threads[i], NULL);
    }

    sem_destroy(&mutex);
    sem_destroy(&resource);
    sem_destroy(&readers);

    return 0;
}

该程序创建了`READERS`个读者线程和`WRITERS`个写者线程，每个线程都会不断地进行读写操作。使用了三个信号量，分别是`mutex`、`resource`、`readers`，分别用于互斥访问读者计数器、互斥访问共享数据、控制读者数量。

在读者线程中，首先使用`readers`信号量来控制读者数量，然后使用`mutex`信号量保护读者计数器，如果是第一个读者，就使用`resource`信号量来保护共享数据；读者读完数据后，还需要再次使用`mutex`信号量来保护读者计数器，如果是最后一个读者，就释放`resource`信号量。

在写者线程中，直接使用`resource`信号量保护共享数据，写完数据后再释放`resource`信号量。

这样，就能够实现读者/写者问题的同步了。