用信号量机制分别实现读者优先和写者优先问题

读者优先和写者优先问题都是读者写者问题的变种。在读者优先问题中，如果有读者正在访问共享资源，则写者需要等待，直到所有读者完成访问。在写者优先问题中，如果有写者正在访问共享资源，则读者需要等待，直到写者完成访问。

为了解决这两种问题，我们可以使用信号量机制来实现。具体实现如下：

读者优先问题：

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

sem_t rw_mutex, mutex;
int read_count = 0, shared_resource = 0;

void *reader(void *arg) {
    int id = *(int *)arg;
    while (1) {
        sem_wait(&mutex);
        read_count++;
        if (read_count == 1)
            sem_wait(&rw_mutex);
        sem_post(&mutex);

        printf("Reader %d read shared resource: %d\n", id, shared_resource);

        sem_wait(&mutex);
        read_count--;
        if (read_count == 0)
            sem_post(&rw_mutex);
        sem_post(&mutex);

        sleep(1);
    }
    return NULL;
}

void *writer(void *arg) {
    int id = *(int *)arg;
    while (1) {
        sem_wait(&rw_mutex);

        shared_resource++;
        printf("Writer %d write shared resource: %d\n", id, shared_resource);

        sem_post(&rw_mutex);

        sleep(3);
    }
    return NULL;
}

int main() {
    pthread_t threads[5];
    int i, readers[3] = {1, 2, 3}, writers[2] = {1, 2};

    sem_init(&rw_mutex, 0, 1);
    sem_init(&mutex, 0, 1);

    for (i = 0; i < 3; i++)
        pthread_create(&threads[i], NULL, reader, &readers[i]);

    for (i = 0; i < 2; i++)
        pthread_create(&threads[i + 3], NULL, writer, &writers[i]);

    for (i = 0; i < 5; i++)
        pthread_join(threads[i], NULL);

    sem_destroy(&rw_mutex);
    sem_destroy(&mutex);

    return 0;
}

在这个例子中，我们使用了两个信号量 `rw_mutex` 和 `mutex`。其中，`rw_mutex` 用于保证写者的互斥访问，`mutex` 用于保证读者计数器的互斥访问。

在读者线程中，我们首先获取 `mutex` 信号量，然后将读者计数器加一。如果读者计数器为 1，则获取 `rw_mutex` 信号量，以保证写者不能同时访问共享资源。然后，我们输出共享资源的值，并将读者计数器减一。如果读者计数器为 0，则释放 `rw_mutex` 信号量，以允许写者访问共享资源。

在写者线程中，我们首先获取 `rw_mutex` 信号量，以保证写者的互斥访问。然后，我们将共享资源的值加一，并输出该值。最后，我们释放 `rw_mutex` 信号量。

写者优先问题：

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

sem_t rw_mutex, mutex;
int read_count = 0, write_count = 0, shared_resource = 0;

void *reader(void *arg) {
    int id = *(int *)arg;
    while (1) {
        sem_wait(&mutex);
        if (write_count > 0)
            sem_post(&mutex);
        else {
            read_count++;
            sem_post(&mutex);

            printf("Reader %d read shared resource: %d\n", id, shared_resource);

            sem_wait(&mutex);
            read_count--;
            if (read_count == 0)
                sem_post(&rw_mutex);
            sem_post(&mutex);
        }
        sleep(1);
    }
    return NULL;
}

void *writer(void *arg) {
    int id = *(int *)arg;
    while (1) {
        sem_wait(&mutex);
        write_count++;
        if (read_count > 0 || write_count > 1)
            sem_post(&mutex);
        else {
            sem_post(&mutex);
            sem_wait(&rw_mutex);

            shared_resource++;
            printf("Writer %d write shared resource: %d\n", id, shared_resource);

            sem_post(&rw_mutex);

            sem_wait(&mutex);
            write_count--;
            sem_post(&mutex);
        }
        sleep(3);
    }
    return NULL;
}

int main() {
    pthread_t threads[5];
    int i, readers[3] = {1, 2, 3}, writers[2] = {1, 2};

    sem_init(&rw_mutex, 0, 1);
    sem_init(&mutex, 0, 1);

    for (i = 0; i < 3; i++)
        pthread_create(&threads[i], NULL, reader, &readers[i]);

    for (i = 0; i < 2; i++)
        pthread_create(&threads[i + 3], NULL, writer, &writers[i]);

    for (i = 0; i < 5; i++)
        pthread_join(threads[i], NULL);

    sem_destroy(&rw_mutex);
    sem_destroy(&mutex);

    return 0;
}

在这个例子中，我们同样使用了两个信号量 `rw_mutex` 和 `mutex`。其中，`rw_mutex` 用于保证写者的互斥访问，`mutex` 用于保证读者和写者计数器的互斥访问。

在读者线程中，我们首先获取 `mutex` 信号量。如果有写者在等待，则释放 `mutex` 信号量，以允许写者先访问共享资源。否则，我们将读者计数器加一，并释放 `mutex` 信号量。然后，我们输出共享资源的值，并将读者计数器减一。如果读者计数器为 0，则释放 `rw_mutex` 信号量，以允许写者访问共享资源。

在写者线程中，我们首先获取 `mutex` 信号量。如果有其他读者或写者在访问共享资源，则释放 `mutex` 信号量，以允许其他线程先访问共享资源。否则，我们将写者计数器加一，并释放 `mutex` 信号量。然后，我们获取 `rw_mutex` 信号量，以保证写者的互斥访问。在访问共享资源时，我们先将共享资源的值加一，并输出该值。最后，我们释放 `rw_mutex` 信号量，并将写者计数器减一。