一组生产者向一组消费者提供消息，它们共享一个有界缓冲区n，生产者向其中投放消息，消费者从中取得消息。 规则： （1）对于生产者进程：产生一个数据，当要送入缓冲区时，要检查缓冲区是否已满，若未满，则可将数据送入缓冲区，并通知消费者进程；否则，等待； （2）对于消费者进程：当它去取数据时，要看缓冲区中是否有数据可取，若有则取走一个数据，并通知生产者进程，否则，等待。 （3）缓冲区是个临界资源，因此，诸进程对缓冲区的操作程序是一个共享临界区，所以，还有个互斥的问题。 给我设计一个C语言程序，由一个父进程创建三个子进程，三个子进程一个是生产者进程，两个是消费者进行，父子进程都使用父进程创建的共享存储区进行通信，由生产者进程将一个数组中的十个数值发送到由5个缓冲区组成的共享内存中，两个消费者进程轮流接收并输出这十个数值，同时将两个消费者进程读出的数值进行累加求和，并写出在ubuntu上实现的步骤。

这是一个经典的生产者消费者问题，可以使用信号量和共享内存实现。下面是一个基于Linux系统的C语言程序的实现步骤：

步骤一：定义共享内存和信号量

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

#define KEY 1234 //共享内存和信号量的key值
#define SHM_SIZE 5 //共享内存的大小
#define SEM_PRODUCER 0 //生产者信号量的编号
#define SEM_CONSUMER 1 //消费者信号量的编号

int shmid; //共享内存的id
int* buffer; //共享内存的指针
int semid; //信号量的id
struct sembuf sem_wait = {0, -1, SEM_UNDO}; //P操作
struct sembuf sem_signal = {0, 1, SEM_UNDO}; //V操作

void init()
{
    //创建共享内存
    shmid = shmget(KEY, SHM_SIZE * sizeof(int), IPC_CREAT | 0666);
    if (shmid < 0) {
        perror("shmget error");
        exit(1);
    }

    //将共享内存映射到进程地址空间
    buffer = (int*)shmat(shmid, NULL, 0);
    if (buffer == (void*)-1) {
        perror("shmat error");
        exit(1);
    }

    //初始化共享内存
    for (int i = 0; i < SHM_SIZE; i++) {
        buffer[i] = 0;
    }

    //创建信号量
    semid = semget(KEY, 2, IPC_CREAT | 0666);
    if (semid < 0) {
        perror("semget error");
        exit(1);
    }

    //初始化生产者信号量
    if (semctl(semid, SEM_PRODUCER, SETVAL, SHM_SIZE) < 0) {
        perror("semctl error");
        exit(1);
    }

    //初始化消费者信号量
    if (semctl(semid, SEM_CONSUMER, SETVAL, 0) < 0) {
        perror("semctl error");
        exit(1);
    }
}

步骤二：定义生产者进程和消费者进程

void producer_process()
{
    int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

    for (int i = 0; i < 10; i++) {
        //等待生产者信号量
        if (semop(semid, &sem_wait, 1) < 0) {
            perror("semop error");
            exit(1);
        }

        //将数据写入共享内存
        buffer[i % SHM_SIZE] = arr[i];
        printf("Producer produced %d\n", arr[i]);

        //释放消费者信号量
        if (semop(semid, &sem_signal, 1) < 0) {
            perror("semop error");
            exit(1);
        }
    }

    exit(0);
}

void consumer_process(int id)
{
    int sum = 0;

    while (1) {
        //等待消费者信号量
        if (semop(semid, &sem_wait, 1) < 0) {
            perror("semop error");
            exit(1);
        }

        //从共享内存中读取数据
        int data = buffer[sum % SHM_SIZE];
        printf("Consumer %d consumed %d\n", id, data);

        //累加求和
        sum += data;

        //释放生产者信号量
        if (semop(semid, &sem_signal, 1) < 0) {
            perror("semop error");
            exit(1);
        }

        //判断是否读取完所有数据
        if (sum == 55) {
            break;
        }
    }

    printf("Consumer %d sum is %d\n", id, sum);

    exit(0);
}

步骤三：定义主函数，创建进程并执行

int main()
{
    init();

    pid_t pid1, pid2, pid3;

    //创建生产者进程
    pid1 = fork();
    if (pid1 < 0) {
        perror("fork error");
        exit(1);
    } else if (pid1 == 0) {
        producer_process();
    }

    //创建消费者进程1
    pid2 = fork();
    if (pid2 < 0) {
        perror("fork error");
        exit(1);
    } else if (pid2 == 0) {
        consumer_process(1);
    }

    //创建消费者进程2
    pid3 = fork();
    if (pid3 < 0) {
        perror("fork error");
        exit(1);
    } else if (pid3 == 0) {
        consumer_process(2);
    }

    //等待子进程结束
    waitpid(pid1, NULL, 0);
    waitpid(pid2, NULL, 0);
    waitpid(pid3, NULL, 0);

    //删除共享内存和信号量
    shmctl(shmid, IPC_RMID, NULL);
    semctl(semid, 0, IPC_RMID);

    return 0;
}

以上就是一个基于Linux系统的生产者消费者问题的C语言程序的实现步骤。