linux c 线程池实现

线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池可以有效地控制系统中并发线程的数量，避免大量线程之间的切换所带来的性能开销。

基础概念

线程池（Thread Pool）：预先创建一定数量的线程，当有任务到来时，从线程池中分配一个空闲线程来执行任务，执行完毕后线程并不销毁，而是回到线程池中等待下一个任务。
工作队列（Work Queue）：用于存储待处理的任务。
线程工厂（Thread Factory）：用于创建新线程。
拒绝策略（Rejection Policy）：当线程池和工作队列都满时，新任务的处理策略。

优势

降低资源消耗：通过重用已创建的线程，减少在创建和销毁线程上花费的时间以及系统资源的开销。
提高响应速度：任务到达时，任务可以不需要等待线程创建就能立即执行。
提高线程的可管理性：线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一分配、调优和监控。

类型

Fixed Thread Pool：线程数量固定的线程池。
Cached Thread Pool：线程数量不固定，根据需要创建新线程，空闲线程会被回收。
Scheduled Thread Pool：支持定时及周期性任务执行的线程池。
Single Thread Executor：只有一个线程的线程池，保证任务顺序执行。

应用场景

Web服务器：处理客户端请求。
数据库连接池：管理数据库连接。
并发计算：如科学计算中的并行处理。
后台任务处理：如定时任务、批处理作业。

实现示例（Linux C语言）

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

typedef struct {
    void (*function)(void *);
    void *argument;
} task_t;

typedef struct {
    task_t *tasks;
    int front;
    int rear;
    int count;
    int capacity;
    pthread_mutex_t lock;
    pthread_cond_t not_empty;
    pthread_cond_t not_full;
} thread_pool_t;

void *worker(void *arg) {
    thread_pool_t *pool = (thread_pool_t *)arg;
    while (1) {
        pthread_mutex_lock(&pool->lock);
        while (pool->count == 0) {
            pthread_cond_wait(&pool->not_empty, &pool->lock);
        }
        task_t task = pool->tasks[pool->front++];
        pool->front %= pool->capacity;
        pool->count--;
        pthread_cond_signal(&pool->not_full);
        pthread_mutex_unlock(&pool->lock);

        task.function(task.argument);
    }
    return NULL;
}

void thread_pool_init(thread_pool_t *pool, int num_threads, int capacity) {
    pool->tasks = (task_t *)malloc(sizeof(task_t) * capacity);
    pool->front = pool->rear = pool->count = 0;
    pool->capacity = capacity;
    pthread_mutex_init(&pool->lock, NULL);
    pthread_cond_init(&pool->not_empty, NULL);
    pthread_cond_init(&pool->not_full, NULL);

    for (int i = 0; i < num_threads; i++) {
        pthread_t thread;
        pthread_create(&thread, NULL, worker, pool);
        pthread_detach(thread);
    }
}

void thread_pool_add_task(thread_pool_t *pool, void (*function)(void *), void *argument) {
    pthread_mutex_lock(&pool->lock);
    while (pool->count == pool->capacity) {
        pthread_cond_wait(&pool->not_full, &pool->lock);
    }
    pool->tasks[pool->rear].function = function;
    pool->tasks[pool->rear].argument = argument;
    pool->rear = (pool->rear + 1) % pool->capacity;
    pool->count++;
    pthread_cond_signal(&pool->not_empty);
    pthread_mutex_unlock(&pool->lock);
}

void example_task(void *arg) {
    int *num = (int *)arg;
    printf("Task %d is running.\n", *num);
}

int main() {
    thread_pool_t pool;
    thread_pool_init(&pool, 4, 10);

    for (int i = 0; i < 10; i++) {
        int *num = (int *)malloc(sizeof(int));
        *num = i;
        thread_pool_add_task(&pool, example_task, num);
    }

    sleep(5); // Wait for tasks to complete
    return 0;
}