1.先初始化缓冲区长度为6： /*buffer.h*/ typedef int buffer_item; #define BUFFER_SIZE 6 2.创建三个信号量：mutex信号量，作为互斥信号量，用于互斥的访问缓冲区； full信号量，判断缓冲区是否有值，初值为0； empty信号量，判断缓冲区是否有空缓冲区，初值为缓冲区数。 3.缓冲将会被用于两个函数：insert_item()和remove_item()。 4.编写两个函数：DWORD WINAPI producer(void *param)和DWORD WINAPI consumer(void *param)，随机函数rand()产生随机数。 5.编写main（）函数，主要功能是： int main(int argc, char *argv[]) { /*1. Get command line arguments argv[1], argv[2], argv[3]*/ /*2. Initialize buffer*/ /*3. Create producer threads(s)*/ /*4. Create consumer threads(s)*/ /*5. Sleep*/ /*6.Exit*/ } 6.打印出相应结果。

以下是一个简单的生产者-消费者问题的代码实现，其中包括了缓冲区的初始化、生产者线程、消费者线程和主函数。

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

#define BUFFER_SIZE 6

typedef int buffer_item;

buffer_item buffer[BUFFER_SIZE];
int buffer_index = 0;

sem_t mutex;
sem_t full;
sem_t empty;

int insert_item(buffer_item item) {
    if (buffer_index < BUFFER_SIZE) {
        buffer[buffer_index++] = item;
        return 0;
    } else {
        return -1;
    }
}

int remove_item(buffer_item *item) {
    if (buffer_index > 0) {
        *item = buffer[--buffer_index];
        return 0;
    } else {
        return -1;
    }
}

void *producer(void *param) {
    buffer_item item;

    while (1) {
        sleep(rand() % 5 + 1);
        item = rand();

        sem_wait(&empty);
        sem_wait(&mutex);

        if (insert_item(item) != 0) {
            printf("Error: Producer failed to insert item into buffer.\n");
        } else {
            printf("Producer produced %d.\n", item);
        }

        sem_post(&mutex);
        sem_post(&full);
    }
}

void *consumer(void *param) {
    buffer_item item;

    while (1) {
        sleep(rand() % 5 + 1);

        sem_wait(&full);
        sem_wait(&mutex);

        if (remove_item(&item) != 0) {
            printf("Error: Consumer failed to remove item from buffer.\n");
        } else {
            printf("Consumer consumed %d.\n", item);
        }

        sem_post(&mutex);
        sem_post(&empty);
    }
}

int main(int argc, char *argv[]) {
    int i, num_producers, num_consumers;
    pthread_t *producers, *consumers;

    if (argc != 4) {
        fprintf(stderr, "Usage: ./producer_consumer <sleep time> <num producers> <num consumers>\n");
        return 1;
    }

    srand(time(NULL));

    sem_init(&mutex, 0, 1);
    sem_init(&full, 0, 0);
    sem_init(&empty, 0, BUFFER_SIZE);

    num_producers = atoi(argv[2]);
    num_consumers = atoi(argv[3]);

    producers = (pthread_t *) malloc(sizeof(pthread_t) * num_producers);
    consumers = (pthread_t *) malloc(sizeof(pthread_t) * num_consumers);

    for (i = 0; i < num_producers; i++) {
        pthread_create(&producers[i], NULL, producer, NULL);
    }

    for (i = 0; i < num_consumers; i++) {
        pthread_create(&consumers[i], NULL, consumer, NULL);
    }

    sleep(atoi(argv[1]));

    free(producers);
    free(consumers);

    return 0;
}

在上面的代码中，我们使用了三个信号量来实现对缓冲区的访问控制：mutex 作为互斥信号量，用于互斥的访问缓冲区；full 信号量用于判断缓冲区是否有值，初值为 0；empty 信号量用于判断缓冲区是否有空缓冲区，初值为缓冲区数。在生产者线程中，我们使用了 rand() 函数来产生一个随机数，然后将其插入到缓冲区中，最后通过 sem_post() 函数来释放信号量。在消费者线程中，我们使用了 sem_wait() 函数来等待信号量，然后从缓冲区中取出数据，并通过 sem_post() 函数来释放信号量。在主函数中，我们使用了 pthread_create() 函数来创建生产者和消费者线程，并使用了 sleep() 函数来让程序在一定时间后退出。