操作系统window下三个进程P1、P2、P3使用包含N个单元的缓冲区，P1每次用Produce()生成一个正整数并用put()送入缓冲区的某个空单元；P2每次用getodd()从该缓冲区中取出一个奇数并用countodd()统计奇数个数；P3每次用geteven()从缓冲区中取出偶数并用counteven()统计偶数个数，请用信号量实现三个进程的同步与互斥活动。

这是一个经典的生产者-消费者问题，可以使用信号量来进行同步与互斥。下面是一种基于信号量的解决方案：

首先，定义以下变量：

int buffer[N];  // 缓冲区
int in = 0;     // 生产者插入位置
int out = 0;    // 消费者读取位置
int count = 0;  // 缓冲区中元素数量
int count_odd = 0;  // 奇数计数器
int count_even = 0; // 偶数计数器

Semaphore mutex = 1;         // 互斥信号量
Semaphore empty = N;         // 缓冲区空槽数量
Semaphore full = 0;          // 缓冲区满槽数量
Semaphore odd_mutex = 1;     // 奇数计数器互斥信号量
Semaphore even_mutex = 1;    // 偶数计数器互斥信号量

其中，`mutex`用于保护临界区（缓冲区的插入和读取操作），`empty`用于表示缓冲区还有多少空槽，`full`用于表示缓冲区有多少满槽，`odd_mutex`和`even_mutex`用于保护奇数和偶数计数器。

接下来，分别定义三个进程的代码：

1. 生产者进程P1：

void producer() {
    while (true) {
        int item = produce();
        sem_wait(&empty);
        sem_wait(&mutex);
        buffer[in] = item;
        in = (in + 1) % N;
        count++;
        sem_post(&mutex);
        sem_post(&full);
    }
}

其中，`produce()`表示生产一个正整数，`sem_wait(&empty)`表示等待空槽（如果缓冲区已满，则阻塞），`sem_wait(&mutex)`表示进入临界区，`sem_post(&mutex)`表示离开临界区，`sem_post(&full)`表示增加满槽数量。

2. 消费者进程P2：

void consumer_odd() {
    while (true) {
        sem_wait(&full);
        sem_wait(&mutex);
        int item = buffer[out];
        out = (out + 1) % N;
        count--;
        sem_post(&mutex);
        sem_post(&empty);
        if (item % 2 == 1) {
            sem_wait(&odd_mutex);
            count_odd++;
            sem_post(&odd_mutex);
        }
    }
}

void consumer_even() {
    while (true) {
        sem_wait(&full);
        sem_wait(&mutex);
        int item = buffer[out];
        out = (out + 1) % N;
        count--;
        sem_post(&mutex);
        sem_post(&empty);
        if (item % 2 == 0) {
            sem_wait(&even_mutex);
            count_even++;
            sem_post(&even_mutex);
        }
    }
}

其中，`sem_wait(&full)`表示等待满槽（如果缓冲区为空，则阻塞），读取缓冲区中的一个元素，将满槽数量减少，如果这个元素是奇数，则增加奇数计数器，如果这个元素是偶数，则增加偶数计数器。

3. 统计器进程P3：

void counter() {
    while (true) {
        // 统计奇数个数
        sem_wait(&odd_mutex);
        printf("Odd count: %d\n", count_odd);
        sem_post(&odd_mutex);

        // 统计偶数个数
        sem_wait(&even_mutex);
        printf("Even count: %d\n", count_even);
        sem_post(&even_mutex);

        // 等待一段时间
        sleep(1);
    }
}

其中，`sem_wait(&odd_mutex)`和`sem_wait(&even_mutex)`分别用于保护奇数和偶数计数器，统计完奇数和偶数个数后，等待一段时间再重新统计。

最后，在`main()`函数中创建三个进程，并等待它们结束：

int main() {
    init_semaphore(&mutex, 1);
    init_semaphore(&empty, N);
    init_semaphore(&full, 0);
    init_semaphore(&odd_mutex, 1);
    init_semaphore(&even_mutex, 1);

    create_thread(&producer);
    create_thread(&consumer_odd);
    create_thread(&consumer_even);
    create_thread(&counter);

    join_thread(&producer);
    join_thread(&consumer_odd);
    join_thread(&consumer_even);
    join_thread(&counter);

    return 0;
}

这样，就完成了对生产者-消费者问题的解决。