用多进程同步方法解决生产者-消费者问题

生产者-消费者问题是指多个线程之间共享一个有限大小的缓冲区，其中生产者线程向缓冲区中放入数据，而消费者线程从缓冲区中取出数据。这个问题的难点在于如何保证生产者和消费者之间的同步和互斥，以确保缓冲区中的数据不会出现竞态条件或死锁等问题。

多进程同步方法可以使用进程间通信（IPC）机制，例如共享内存或消息队列，来解决生产者-消费者问题。下面是一个使用共享内存和信号量的示例代码：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/sem.h>

#define SHM_SIZE 1024
#define MUTEX 0
#define FULL 1
#define EMPTY 2

void producer(int *buffer, int *in, int *out, int *count, int shmid, int semid) {
    while (1) {
        // 生产者等待空缓冲区
        struct sembuf sem_op;
        sem_op.sem_num = EMPTY;
        sem_op.sem_op = -1;
        sem_op.sem_flg = 0;
        semop(semid, &sem_op, 1);

        // 生产者获取互斥锁
        sem_op.sem_num = MUTEX;
        sem_op.sem_op = -1;
        sem_op.sem_flg = 0;
        semop(semid, &sem_op, 1);

        // 向缓冲区中放入数据
        buffer[*in] = rand() % 100;
        printf("producer put %d in buffer[%d]\n", buffer[*in], *in);
        *in = (*in + 1) % SHM_SIZE;
        (*count)++;

        // 生产者释放互斥锁
        sem_op.sem_num = MUTEX;
        sem_op.sem_op = 1;
        sem_op.sem_flg = 0;
        semop(semid, &sem_op, 1);

        // 生产者通知缓冲区已有数据
        sem_op.sem_num = FULL;
        sem_op.sem_op = 1;
        sem_op.sem_flg = 0;
        semop(semid, &sem_op, 1);

        sleep(1);
    }
}

void consumer(int *buffer, int *in, int *out, int *count, int shmid, int semid) {
    while (1) {
        // 消费者等待有数据的缓冲区
        struct sembuf sem_op;
        sem_op.sem_num = FULL;
        sem_op.sem_op = -1;
        sem_op.sem_flg = 0;
        semop(semid, &sem_op, 1);

        // 消费者获取互斥锁
        sem_op.sem_num = MUTEX;
        sem_op.sem_op = -1;
        sem_op.sem_flg = 0;
        semop(semid, &sem_op, 1);

        // 从缓冲区中取出数据
        int value = buffer[*out];
        printf("consumer get %d from buffer[%d]\n", value, *out);
        *out = (*out + 1) % SHM_SIZE;
        (*count)--;

        // 消费者释放互斥锁
        sem_op.sem_num = MUTEX;
        sem_op.sem_op = 1;
        sem_op.sem_flg = 0;
        semop(semid, &sem_op, 1);

        // 消费者通知缓冲区已有空闲位置
        sem_op.sem_num = EMPTY;
        sem_op.sem_op = 1;
        sem_op.sem_flg = 0;
        semop(semid, &sem_op, 1);

        sleep(2);
    }
}

int main() {
    // 创建共享内存和信号量
    int shmid = shmget(IPC_PRIVATE, SHM_SIZE * sizeof(int), IPC_CREAT | 0666);
    int semid = semget(IPC_PRIVATE, 3, IPC_CREAT | 0666);
    if (shmid == -1 || semid == -1) {
        perror("shmget/semget error");
        exit(1);
    }

    // 初始化共享内存和信号量
    int *buffer = (int *) shmat(shmid, NULL, 0);
    int *in = (int *) shmat(shmid, NULL, 0) + 1;
    int *out = (int *) shmat(shmid, NULL, 0) + 2;
    int *count = (int *) shmat(shmid, NULL, 0) + 3;
    *in = 0;
    *out = 0;
    *count = 0;
    semctl(semid, MUTEX, SETVAL, 1);
    semctl(semid, FULL, SETVAL, 0);
    semctl(semid, EMPTY, SETVAL, SHM_SIZE);

    // 创建生产者和消费者进程
    pid_t pid;
    if ((pid = fork()) < 0) {
        perror("fork error");
        exit(1);
    } else if (pid == 0) {
        producer(buffer, in, out, count, shmid, semid);
        exit(0);
    }
    if ((pid = fork()) < 0) {
        perror("fork error");
        exit(1);
    } else if (pid == 0) {
        consumer(buffer, in, out, count, shmid, semid);
        exit(0);
    }

    // 等待子进程结束
    for (int i = 0; i < 2; i++) {
        wait(NULL);
    }

    // 删除共享内存和信号量
    shmdt(buffer);
    shmdt(in);
    shmdt(out);
    shmdt(count);
    shmctl(shmid, IPC_RMID, NULL);
    semctl(semid, 0, IPC_RMID);
}

在这个示例代码中，我们使用了共享内存来存放缓冲区、指针和计数器等信息，并使用了信号量来进行同步和互斥操作。其中，MUTEX信号量用于互斥操作，FULL信号量用于表示缓冲区中已有数据，EMPTY信号量用于表示缓冲区中还有多少空闲位置。

生产者和消费者进程分别进行自己的操作，当生产者向缓冲区中放入数据时，需要等待EMPTY信号量，获取MUTEX信号量，放入数据后释放MUTEX信号量并通知FULL信号量；当消费者从缓冲区中取出数据时，需要等待FULL信号量，获取MUTEX信号量，取出数据后释放MUTEX信号量并通知EMPTY信号量。

通过这种方式，我们可以解决生产者-消费者问题，并且可以通过多进程的方式来提高程序的性能和可靠性。