创建5个进程，其中两个进程为生产者进程，3个进程为消费者进程。一个生产者进程试图不断地在一个缓冲中写入大写字母，另一个生产者进程试图不断地在缓冲中写入小写字母。3个消费者不断地从缓冲中读取一个字符并输出。为了使得程序的输出易于看到结果，仿照的实例程序，分别在生产者和消费者进程的合适的位置加入一些随机睡眠时间。

以下是一个简单的实现该需求的程序，使用信号量和共享内存实现进程间通信：

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

#define BUFFER_SIZE 10

// 定义信号量和共享内存的键值
#define SEM_KEY 1234
#define SHM_KEY 5678

// 定义信号量的编号
#define MUTEX 0
#define FULL 1
#define EMPTY 2

// 定义信号量操作函数
void sem_wait(int semid, int semnum) {
    struct sembuf sb = {semnum, -1, 0};
    semop(semid, &sb, 1);
}

void sem_signal(int semid, int semnum) {
    struct sembuf sb = {semnum, 1, 0};
    semop(semid, &sb, 1);
}

int main() {
    // 创建信号量和共享内存
    int semid = semget(SEM_KEY, 3, IPC_CREAT | 0666);
    int shmid = shmget(SHM_KEY, BUFFER_SIZE, IPC_CREAT | 0666);
    char *buffer = shmat(shmid, NULL, 0);

    // 初始化信号量
    semctl(semid, MUTEX, SETVAL, 1);
    semctl(semid, FULL, SETVAL, 0);
    semctl(semid, EMPTY, SETVAL, BUFFER_SIZE);

    // 创建生产者进程1
    if (fork() == 0) {
        while (1) {
            // 随机睡眠一段时间
            usleep(rand() % 1000000);

            sem_wait(semid, EMPTY);
            sem_wait(semid, MUTEX);

            // 写入大写字母
            int index = rand() % BUFFER_SIZE;
            buffer[index] = 'A' + rand() % 26;
            printf("Producer1 produced %c\n", buffer[index]);

            sem_signal(semid, MUTEX);
            sem_signal(semid, FULL);
        }
    }

    // 创建生产者进程2
    if (fork() == 0) {
        while (1) {
            // 随机睡眠一段时间
            usleep(rand() % 1000000);

            sem_wait(semid, EMPTY);
            sem_wait(semid, MUTEX);

            // 写入小写字母
            int index = rand() % BUFFER_SIZE;
            buffer[index] = 'a' + rand() % 26;
            printf("Producer2 produced %c\n", buffer[index]);

            sem_signal(semid, MUTEX);
            sem_signal(semid, FULL);
        }
    }

    // 创建消费者进程1
    if (fork() == 0) {
        while (1) {
            // 随机睡眠一段时间
            usleep(rand() % 1000000);

            sem_wait(semid, FULL);
            sem_wait(semid, MUTEX);

            // 读取并输出字符
            int index = rand() % BUFFER_SIZE;
            char c = buffer[index];
            printf("Consumer1 consumed %c\n", c);

            sem_signal(semid, MUTEX);
            sem_signal(semid, EMPTY);
        }
    }

    // 创建消费者进程2
    if (fork() == 0) {
        while (1) {
            // 随机睡眠一段时间
            usleep(rand() % 1000000);

            sem_wait(semid, FULL);
            sem_wait(semid, MUTEX);

            // 读取并输出字符
            int index = rand() % BUFFER_SIZE;
            char c = buffer[index];
            printf("Consumer2 consumed %c\n", c);

            sem_signal(semid, MUTEX);
            sem_signal(semid, EMPTY);
        }
    }

    // 创建消费者进程3
    if (fork() == 0) {
        while (1) {
            // 随机睡眠一段时间
            usleep(rand() % 1000000);

            sem_wait(semid, FULL);
            sem_wait(semid, MUTEX);

            // 读取并输出字符
            int index = rand() % BUFFER_SIZE;
            char c = buffer[index];
            printf("Consumer3 consumed %c\n", c);

            sem_signal(semid, MUTEX);
            sem_signal(semid, EMPTY);
        }
    }

    // 等待子进程结束
    wait(NULL);

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

    return 0;
}

该程序创建了5个进程，其中两个为生产者进程，三个为消费者进程。生产者进程1不断地在缓冲中写入大写字母，生产者进程2不断地在缓冲中写入小写字母。消费者进程不断地从缓冲中读取一个字符并输出。为了使得程序的输出易于看到结果，程序中在生产者和消费者进程的合适位置加入了随机睡眠时间。程序使用信号量和共享内存实现进程间通信。其中，信号量用于同步和互斥，共享内存用于存储缓冲区。