编写一个程序primer_pro3.c，用父进程创建一块共享存储器实现。程序运行开始时，创建10个子进程和一个包含20个元素的队列，父进程不断地依次将30000000到30000200之间这200个数放入队列，如果队列满，则父进程等待。

好的，这是一个使用共享内存的例子。下面是代码：

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

#define MAX_PROCESSES 10
#define QUEUE_SIZE 20

typedef struct {
    int data[QUEUE_SIZE];
    int head;
    int tail;
} queue_t;

int shmid;
queue_t *queue;

void worker() {
    while (1) {
        int num;
        while (queue->head == queue->tail) {
            sleep(1);
        }
        num = queue->data[queue->head];
        queue->head = (queue->head + 1) % QUEUE_SIZE;
        printf("Processed: %d\n", num*num);
    }
}

void parent() {
    int i;
    for (i = 30000000; i < 30000200; i++) {
        while ((queue->tail + 1) % QUEUE_SIZE == queue->head) {
            sleep(1);
        }
        queue->data[queue->tail] = i;
        queue->tail = (queue->tail + 1) % QUEUE_SIZE;
        printf("Sent: %d\n", i);
    }
}

int main() {
    int i;
    pid_t pid;
    key_t key = ftok(".", 'q');
    shmid = shmget(key, sizeof(queue_t), IPC_CREAT | 0666);
    if (shmid == -1) {
        perror("shmget");
        exit(1);
    }
    queue = shmat(shmid, NULL, 0);
    if (queue == (void*) -1) {
        perror("shmat");
        exit(1);
    }
    queue->head = 0;
    queue->tail = 0;
    for (i = 0; i < MAX_PROCESSES; i++) {
        pid = fork();
        if (pid == -1) {
            perror("fork");
            exit(1);
        } else if (pid == 0) {
            worker();
            exit(0);
        }
    }
    parent();
    for (i = 0; i < MAX_PROCESSES; i++) {
        wait(NULL);
    }
    shmdt(queue);
    shmctl(shmid, IPC_RMID, NULL);
    return 0;
}

程序中使用了一块共享内存来实现子进程和父进程之间的通信，父进程向队列中发送数据，子进程从队列中取出数据进行处理。

共享内存的创建和删除使用了`shmget`和`shmctl`函数，共享内存的附加和分离使用了`shmat`和`shmdt`函数。

程序中创建了10个子进程，每个子进程通过循环调用`worker`函数来不断从队列中取出数据进行处理。

父进程则通过循环调用`parent`函数来不断向队列中发送数据，如果队列已满，则等待。

注意，程序中使用了循环来处理队列满的情况，这样可以让父进程在队列已满的情况下不会一直等待，而是每隔一段时间就检查一次队列是否已经有空闲位置。同时，子进程也会每隔一段时间就检查一次队列是否有数据可供处理。