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

以下是一个可能的解法，使用了条件变量来实现进程之间的同步与互斥：

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

#define BUFFER_SIZE 5

int buffer[BUFFER_SIZE]; // 缓冲区
int in = 0, out = 0; // 缓冲区指针
int odd_ready = 0, even_ready = 0; // 标记位
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; // 互斥锁
pthread_cond_t empty = PTHREAD_COND_INITIALIZER; // 空缓冲区条件变量
pthread_cond_t odd = PTHREAD_COND_INITIALIZER; // 奇数条件变量
pthread_cond_t even = PTHREAD_COND_INITIALIZER; // 偶数条件变量

void *producer(void *arg) {
    int item;
    while (1) {
        // 生成随机数
        item = rand() % 100;

        // 获取互斥锁
        pthread_mutex_lock(&mutex);

        // 等待空缓冲区
        while ((in + 1) % BUFFER_SIZE == out || odd_ready || even_ready) {
            pthread_cond_wait(&empty, &mutex);
        }

        // 存入缓冲区
        buffer[in] = item;
        printf("Producer: %d\n", item);
        in = (in + 1) % BUFFER_SIZE;

        // 设置标记位
        if (item % 2 == 0) {
            even_ready = 1; // 偶数
        } else {
            odd_ready = 1; // 奇数
        }

        // 发送信号
        pthread_cond_signal(&odd);
        pthread_cond_signal(&even);

        // 释放互斥锁
        pthread_mutex_unlock(&mutex);

        // 休眠
        sleep(1);
    }
}

void *consumer_odd(void *arg) {
    int item;
    while (1) {
        // 获取互斥锁
        pthread_mutex_lock(&mutex);

        // 等待奇数
        while (!odd_ready) {
            pthread_cond_wait(&odd, &mutex);
        }

        // 取出缓冲区中的奇数
        item = buffer[out];
        printf("Consumer(Odd): %d\n", item);
        out = (out + 1) % BUFFER_SIZE;

        // 清除标记位
        odd_ready = 0;

        // 发送信号
        pthread_cond_signal(&empty);

        // 释放互斥锁
        pthread_mutex_unlock(&mutex);

        // 休眠
        sleep(1);
    }
}

void *consumer_even(void *arg) {
    int item;
    while (1) {
        // 获取互斥锁
        pthread_mutex_lock(&mutex);

        // 等待偶数
        while (!even_ready) {
            pthread_cond_wait(&even, &mutex);
        }

        // 取出缓冲区中的偶数
        item = buffer[out];
        printf("Consumer(Even): %d\n", item);
        out = (out + 1) % BUFFER_SIZE;

        // 清除标记位
        even_ready = 0;

        // 发送信号
        pthread_cond_signal(&empty);

        // 释放互斥锁
        pthread_mutex_unlock(&mutex);

        // 休眠
        sleep(1);
    }
}

int main() {
    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);

    // 销毁互斥锁和条件变量
    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&empty);
    pthread_cond_destroy(&odd);
    pthread_cond_destroy(&even);

    return 0;
}

其中，生产者线程会不断生成随机数并存入缓冲区，根据数值的奇偶性，设置对应的标记位和发送对应的条件变量。消费者线程会等待对应的条件变量，然后取出缓冲区中的数并打印，最后发送空缓冲区的条件变量。互斥锁用于实现互斥访问缓冲区。