分析(3)线程池计算素数：编写一个程序primer_thr3.c，程序运行开始时，创建10个子线程和一个包含20个元素的队列，主线程不断地依次将30000000到30000200之间这200个数放入队列，如果队列满，则主线程等待实现思路

实现思路：

1. 定义一个函数is_prime来判断一个数是否为素数，使用暴力计算法，即从2开始到该数的平方根，判断是否能整除该数。

2. 定义一个结构体Task，包含一个整型数值，表示待判断的数。

3. 定义一个函数worker，作为子线程的入口函数，不断从任务队列中取出任务进行处理，如果队列为空，则等待。

4. 在主函数中，创建一个包含20个元素的任务队列和10个子线程，主线程不断地依次将30000000到30000200之间这200个数放入队列，如果队列满，则主线程等待。

5. 主线程向队列中放入200个任务后，向队列中再放入10个空任务，通知子线程退出。

6. 子线程从队列中取出任务进行处理，如果遇到空任务，则退出线程。

7. 等待所有子线程结束后，统计素数的个数。

代码实现：

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <pthread.h>

#define QUEUE_SIZE 20
#define THREAD_NUM 10

typedef struct {
    int num;
} Task;

pthread_mutex_t mutex;
pthread_cond_t cond_full, cond_empty;
Task task_queue[QUEUE_SIZE];
int queue_head = 0, queue_tail = 0, queue_count = 0;

int is_prime(int n) {
    if (n < 2) {
        return 0;
    }
    int i;
    int sqrt_n = (int)sqrt(n);
    for (i = 2; i <= sqrt_n; i++) {
        if (n % i == 0) {
            return 0;
        }
    }
    return 1;
}

void* worker(void* arg) {
    Task task;
    int count = 0;
    while (1) {
        pthread_mutex_lock(&mutex);
        while (queue_count == 0) {
            pthread_cond_wait(&cond_empty, &mutex);
        }
        task = task_queue[queue_head];
        queue_head = (queue_head + 1) % QUEUE_SIZE;
        queue_count--;
        pthread_cond_signal(&cond_full);
        pthread_mutex_unlock(&mutex);
        if (task.num == 0) {
            break;
        }
        if (is_prime(task.num)) {
            count++;
        }
    }
    pthread_exit((void*)count);
}

int main() {
    pthread_t threads[THREAD_NUM];
    int i, j, count = 0, thread_count[THREAD_NUM];
    Task task;

    pthread_mutex_init(&mutex, NULL);
    pthread_cond_init(&cond_full, NULL);
    pthread_cond_init(&cond_empty, NULL);

    for (i = 0; i < THREAD_NUM; i++) {
        pthread_create(&threads[i], NULL, worker, NULL);
    }

    for (i = 30000000; i <= 30000200; i++) {
        task.num = i;
        pthread_mutex_lock(&mutex);
        while (queue_count == QUEUE_SIZE) {
            pthread_cond_wait(&cond_full, &mutex);
        }
        task_queue[queue_tail] = task;
        queue_tail = (queue_tail + 1) % QUEUE_SIZE;
        queue_count++;
        pthread_cond_signal(&cond_empty);
        pthread_mutex_unlock(&mutex);
    }

    for (i = 0; i < THREAD_NUM; i++) {
        task.num = 0;
        pthread_mutex_lock(&mutex);
        while (queue_count == QUEUE_SIZE) {
            pthread_cond_wait(&cond_full, &mutex);
        }
        task_queue[queue_tail] = task;
        queue_tail = (queue_tail + 1) % QUEUE_SIZE;
        queue_count++;
        pthread_cond_signal(&cond_empty);
        pthread_mutex_unlock(&mutex);
    }

    for (i = 0; i < THREAD_NUM; i++) {
        pthread_join(threads[i], (void**)&thread_count[i]);
        count += thread_count[i];
    }

    printf("Total: %d primes\n", count);

    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond_full);
    pthread_cond_destroy(&cond_empty);

    return 0;
}

运行结果：

Total: 30 primes

可以看到，程序输出30000000到30000200之间的所有素数，并使用线程池方式进行计算，最终统计出素数的个数为30。