通过共享内存的方式解决生产者消费者问题写出代码

下面是一个使用共享内存的生产者消费者问题的代码示例，其中使用了信号量来实现同步和互斥：

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

#define BUFFER_SIZE 10

typedef struct {
    int buffer[BUFFER_SIZE];
    sem_t full;   // 用于同步生产者和消费者的信号量
    sem_t empty;  // 用于保证缓冲区不会溢出的信号量
    int in;       // 缓冲区的下一个可写位置
    int out;      // 缓冲区的下一个可读位置
} shm_buffer;

int main()
{
    int shmid;
    shm_buffer *buffer;
    pid_t pid;

    // 创建共享内存
    shmid = shmget(IPC_PRIVATE, sizeof(shm_buffer), 0666 | IPC_CREAT);
    if (shmid == -1) {
        perror("shmget");
        exit(EXIT_FAILURE);
    }

    // 连接共享内存
    buffer = (shm_buffer*) shmat(shmid, NULL, 0);
    if (buffer == (shm_buffer*)-1) {
        perror("shmat");
        exit(EXIT_FAILURE);
    }

    // 初始化信号量
    sem_init(&(buffer->empty), 1, BUFFER_SIZE);
    sem_init(&(buffer->full), 1, 0);

    // 创建子进程
    pid = fork();
    if (pid == -1) {
        perror("fork");
        exit(EXIT_FAILURE);
    }

    if (pid == 0) {  // 子进程为消费者
        int value;
        while (1) {
            sem_wait(&(buffer->full));  // 等待生产者放入数据
            sem_wait(&(buffer->empty)); // 等待缓冲区有可读数据
            value = buffer->buffer[buffer->out];
            buffer->out = (buffer->out + 1) % BUFFER_SIZE;
            printf("Consumer consumes %d\n", value);
            sem_post(&(buffer->empty)); // 释放空缓冲区
        }
        exit(EXIT_SUCCESS);
    } else {         // 父进程为生产者
        int value = 0;
        while (1) {
            sem_wait(&(buffer->empty)); // 等待缓冲区有空位置
            buffer->buffer[buffer->in] = value;
            buffer->in = (buffer->in + 1) % BUFFER_SIZE;
            printf("Producer produces %d\n", value++);
            sem_post(&(buffer->full));  // 释放满缓冲区
            sleep(1);
        }
    }

    // 删除共享内存和信号量
    shmdt(buffer);
    shmctl(shmid, IPC_RMID, NULL);
    sem_destroy(&(buffer->full));
    sem_destroy(&(buffer->empty));

    return 0;
}

在这个代码示例中，我们定义了一个 `shm_buffer` 结构体来存储共享内存中的缓冲区和信号量。生产者和消费者进程通过共享内存中的 `buffer` 指针来访问缓冲区，同时使用 `full` 和 `empty` 信号量来实现同步和互斥。在生产者进程中，当缓冲区满时，生产者将等待消费者取出数据后再继续生产；在消费者进程中，当缓冲区为空时，消费者将等待生产者放入数据后再继续消费。