如果有三个进程R、WW1、WW2共享一个缓冲器B，而B中每次只能存放个数。当缓冲器中无数时，进程R可以将从输入设备上迹入的数存放到缪冲器中。若存放到缓冲哭中的是奇数，则允许进程W1将其取出打印，若在放到缓冲器中的是偶数，则允许进程W2将其取出打印。同的规定，进程R必须等缓冲区中的数被取出打印后才能再存放1个数，进程w1或W2对每次存入缓冲器的数只能打印一次，W1和W2都不能从缓冲中取数。写出这三个并发进程能正确工作的程序

以下一个可能的解决方案，使用互斥锁和条件变量来同步进程：

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

#define BUFFER_SIZE 10

int buffer[BUFFER_SIZE];
int count = 0;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_odd = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond_even = PTHREAD_COND_INITIALIZER;

void *producer(void *arg) {
    int num;
    while (1) {
        num = rand() % 100;
        pthread_mutex_lock(&lock);
        while (count == BUFFER_SIZE) {
            pthread_cond_wait(&cond_odd, &lock);
            pthread_cond_wait(&cond_even, &lock);
        }
        buffer[count++] = num;
        printf("Producer produces %d\n", num);
        if (num % 2 == 0) {
            pthread_cond_signal(&cond_even);
        } else {
            pthread_cond_signal(&cond_odd);
        }
        pthread_mutex_unlock(&lock);
    }
}

void *consumer_odd(void *arg) {
    while (1) {
        pthread_mutex_lock(&lock);
        while (count == 0 || buffer[count-1] % 2 == 0) {
            pthread_cond_wait(&cond_odd, &lock);
        }
        int num = buffer[--count];
        printf("Consumer odd prints %d\n", num);
        pthread_cond_signal(&cond_even);
        pthread_mutex_unlock(&lock);
    }
}

void *consumer_even(void *arg) {
    while (1) {
        pthread_mutex_lock(&lock);
        while (count == 0 || buffer[count-1] % 2 == 1) {
            pthread_cond_wait(&cond_even, &lock);
        }
        int num = buffer[--count];
        printf("Consumer even prints %d\n", num);
        pthread_cond_signal(&cond_odd);
        pthread_mutex_unlock(&lock);
    }
}

int main() {
    srand(time(NULL));

    pthread_t tid_producer, tid_consumer_odd, tid_consumer_even;
    pthread_create(&tid_producer, NULL, producer, NULL);
    pthread_create(&tid_consumer_odd, NULL, consumer_odd, NULL);
    pthread_create(&tid_consumer_even, NULL, consumer_even, NULL);

    pthread_join(tid_producer, NULL);
    pthread_join(tid_consumer_odd, NULL);
    pthread_join(tid_consumer_even, NULL);

    return 0;
}

解释：

- 进程R作为生产者，不断产生随机数，并将其存入缓冲器中。
- 进程W1和W2分别作为两个消费者，不断从缓冲器中取出数，如果是奇数就打印，如果是偶数就打印。
- 互斥锁`lock`用于保护临界区，即缓冲器`buffer`和计数器`count`。
- 条件变量`cond_odd`和`cond_even`分别用于控制奇数和偶数的处理顺序。
- 在生产者中，如果缓冲器已满，生产者就等待条件变量`cond_odd`和`cond_even`中的一个，阻塞自己，直到有消费者唤醒它。
- 在消费者中，如果缓冲器为空或者最后一个数不符合消费者的要求，就等待条件变量`cond_odd`或`cond_even`，阻塞自己，直到生产者唤醒它。
- 每次生产者往缓冲器中存入数时，都唤醒适当的消费者，让它们争抢缓冲器中的数。
- 每次消费者取出数时，都唤醒另一个消费者，让它们轮流工作。

当然，这只是一个参考实现，可能还有其他的正确实现方案。