(3) 实现进程池计算素数：编写一个程序primer_pro3.c，程序运行开始时，创建10个子进程和一个包含20个元素的队列，父进程不断地依次将30000000到30000200之间这200个数放入队列，如果队列满，则父进程等待。  队列的定义可参考如下： #define MAXSIZE 20 struct quequ_st{ int finished; //父进程是否已将所有200个整数放入了队列 int head; //队列头 int tail; //队列尾 char data[MAXSIZE]; //队列数据 int count; //当前队列中数据个数

下面是实现进程池计算素数的代码：

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

#define MAXSIZE 20
#define NUM_CHILDREN 10

struct queue_st {
    int finished;
    int head;
    int tail;
    char data[MAXSIZE];
    int count;
};

void init_queue(struct queue_st *q) {
    q->finished = 0;
    q->head = 0;
    q->tail = 0;
    memset(q->data, 0, MAXSIZE);
    q->count = 0;
}

int is_queue_empty(struct queue_st *q) {
    return q->head == q->tail && q->count == 0;
}

int is_queue_full(struct queue_st *q) {
    return q->head == q->tail && q->count > 0;
}

void enqueue(struct queue_st *q, char n) {
    while (is_queue_full(q)) {
        usleep(1000);
    }
    q->data[q->tail] = n;
    q->tail = (q->tail + 1) % MAXSIZE;
    q->count++;
}

char dequeue(struct queue_st *q) {
    while (is_queue_empty(q) && !q->finished) {
        usleep(1000);
    }
    char n = q->data[q->head];
    q->head = (q->head + 1) % MAXSIZE;
    q->count--;
    return n;
}

int is_prime(int n) {
    if (n <= 1) {
        return 0;
    }

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

    return 1;
}

void child_process(struct queue_st *q, int id) {
    while (1) {
        char n = dequeue(q);
        if (n == -1) {
            break;
        }

        if (is_prime(n)) {
            printf("Process %d found prime: %d\n", id, n);
        }
    }
}

void parent_process(struct queue_st *q) {
    int i;
    for (i = 30000000; i < 30000200; i++) {
        enqueue(q, i);
    }
    q->finished = 1;

    for (i = 0; i < NUM_CHILDREN; i++) {
        enqueue(q, -1);
    }

    for (i = 0; i < NUM_CHILDREN; i++) {
        wait(NULL);
    }
}

int main() {
    struct queue_st q;
    init_queue(&q);

    int i;
    for (i = 0; i < NUM_CHILDREN; i++) {
        pid_t pid = fork();
        if (pid == 0) {
            child_process(&q, i);
            exit(0);
        }
    }

    parent_process(&q);

    return 0;
}

程序运行时，先创建10个子进程，然后父进程不断地将30000000到30000200之间的200个数放入队列中，每当队列满时，父进程就会等待。子进程从队列中获取数据，并判断是否为素数，如果是素数则输出。当父进程将所有数放入队列后，会向队列中加入10个-1，表示所有数已经放完，子进程可以退出。最后，父进程等待所有子进程结束后才会退出。