多个生产者进程和多个消费者进程并发执行,并采用信号量机制与P/V操作实现进程代码

这里提供一个简单的生产者-消费者问题的解决方案，采用信号量机制和P/V操作实现进程代码。具体实现语言为C。

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

#define BUFFER_SIZE 5    // 缓冲区大小
#define PRODUCER_NUM 2   // 生产者数目
#define CONSUMER_NUM 2   // 消费者数目

sem_t empty;            // 空缓冲区信号量
sem_t full;             // 满缓冲区信号量
pthread_mutex_t mutex;  // 互斥锁

int buffer[BUFFER_SIZE]; // 缓冲区
int in = 0;              // 生产者放置数据的位置
int out = 0;             // 消费者取走数据的位置

void *producer(void *arg) {
    int id = *(int *) arg;
    for (int i = 0; i < 10; ++i) {
        sem_wait(&empty);          // 等待空缓冲区
        pthread_mutex_lock(&mutex); // 加锁
        buffer[in] = i;             // 放置数据
        printf("Producer %d put %d in buffer[%d]\n", id, i, in);
        in = (in + 1) % BUFFER_SIZE; // 更新in指针
        pthread_mutex_unlock(&mutex); // 解锁
        sem_post(&full);               // 发布满缓冲区信号
    }
    return NULL;
}

void *consumer(void *arg) {
    int id = *(int *) arg;
    int data;
    for (int i = 0; i < 10; ++i) {
        sem_wait(&full);            // 等待满缓冲区
        pthread_mutex_lock(&mutex); // 加锁
        data = buffer[out];         // 取出数据
        printf("Consumer %d get %d from buffer[%d]\n", id, data, out);
        out = (out + 1) % BUFFER_SIZE; // 更新out指针
        pthread_mutex_unlock(&mutex); // 解锁
        sem_post(&empty);               // 发布空缓冲区信号
    }
    return NULL;
}

int main() {
    pthread_t producer_tid[PRODUCER_NUM];
    pthread_t consumer_tid[CONSUMER_NUM];
    int i, id[PRODUCER_NUM + CONSUMER_NUM];

    sem_init(&empty, 0, BUFFER_SIZE); // 初始化信号量
    sem_init(&full, 0, 0);
    pthread_mutex_init(&mutex, NULL);

    // 创建生产者线程
    for (i = 0; i < PRODUCER_NUM; ++i) {
        id[i] = i;
        pthread_create(&producer_tid[i], NULL, producer, &id[i]);
    }

    // 创建消费者线程
    for (i = 0; i < CONSUMER_NUM; ++i) {
        id[i + PRODUCER_NUM] = i;
        pthread_create(&consumer_tid[i], NULL, consumer, &id[i + PRODUCER_NUM]);
    }

    // 等待生产者线程结束
    for (i = 0; i < PRODUCER_NUM; ++i) {
        pthread_join(producer_tid[i], NULL);
    }

    // 等待消费者线程结束
    for (i = 0; i < CONSUMER_NUM; ++i) {
        pthread_join(consumer_tid[i], NULL);
    }

    sem_destroy(&empty); // 销毁信号量和互斥锁
    sem_destroy(&full);
    pthread_mutex_destroy(&mutex);

    return 0;
}

以上是一个简单的生产者-消费者问题解决方案，采用信号量机制和P/V操作实现进程代码。主要思路是使用两个信号量实现同步和互斥，生产者线程等待空缓冲区信号量，消费者线程等待满缓冲区信号量。当生产者向缓冲区放置数据时，需要加锁，以保证同一时间只有一个生产者访问缓冲区；当消费者从缓冲区取走数据时，也需要加锁，以保证同一时间只有一个消费者访问缓冲区。同时，当生产者放置数据后，需要发布满缓冲区信号量，以通知消费者可以从缓冲区中取数据；当消费者取走数据后，需要发布空缓冲区信号量，以通知生产者可以向缓冲区中放数据。