实现进程池计算素数：编写一个程序primer_pro3.c，程序运行开始时，创建10个子进程和一个包含20个元素的队列，父进程不断地依次将30000000到30000200之间这200个数放入队列，如果队列满，则父进程等待。记录每次运行的时间，并计算平均运行时间。

好的，我会为您解答。以下是实现进程池计算素数的primer_pro3.c程序：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <time.h>

#define MAX_QUEUE_SIZE 20
#define MAX_CHILDREN_NUM 10

typedef struct {
    int num[MAX_QUEUE_SIZE];
    int front, rear;
} Queue;

int is_prime(int num) {
    if (num <= 1) return 0;
    for (int i = 2; i * i <= num; ++i) {
        if (num % i == 0) return 0;
    }
    return 1;
}

void enqueue(Queue *queue, int num) {
    queue->num[queue->rear] = num;
    queue->rear = (queue->rear + 1) % MAX_QUEUE_SIZE;
}

int dequeue(Queue *queue) {
    int res = queue->num[queue->front];
    queue->front = (queue->front + 1) % MAX_QUEUE_SIZE;
    return res;
}

int main() {
    Queue queue = { .front = 0, .rear = 0 };
    int count = 0, sum_time = 0;

    for (int i = 0; i < MAX_CHILDREN_NUM; ++i) {
        pid_t pid = fork();
        if (pid == 0) {
            while (1) {
                int num = dequeue(&queue);
                if (is_prime(num)) {
                    printf("%d is a prime number.\n", num);
                }
                if (queue.front == queue.rear) exit(0);
            }
        }
    }

    clock_t start_time = clock();
    for (int i = 30000000; i <= 30000200; ++i) {
        while ((queue.rear + 1) % MAX_QUEUE_SIZE == queue.front) {
            wait(NULL);
            --count;
        }
        enqueue(&queue, i);
        ++count;
    }
    while (count > 0) {
        wait(NULL);
        --count;
    }
    clock_t end_time = clock();

    sum_time += (int)(end_time - start_time);
    printf("Time used: %dms\n", sum_time);

    return 0;
}

该程序首先定义了一个队列结构体Queue，用于存储待处理的数值。每个子进程都会不断地从队列中取出数值，并判断是否为素数。如果是素数，则输出结果。当队列为空时，子进程会退出。

在主进程中，首先创建了10个子进程，并将30000000到30000200之间的200个数放入队列中。如果队列已满，则主进程会等待。当所有数值处理完毕后，主进程会等待所有子进程退出，并记录运行时间。

需要注意的是，由于使用了进程池技术，每个子进程处理完一个数值后会立即取出下一个数值进行处理，因此程序具有一定的并发性能，可以大大提高计算速度。