typedef struct {
    void (*routine)(void *arg);  // 任務(wù)執(zhí)行的函數(shù)
    void *arg;                   // 傳遞給任務(wù)函數(shù)的參數(shù)
} task_t;

typedef struct {
    pthread_t *threads;           // 工作線程數(shù)組
    task_t *task_queue;           // 任務(wù)隊(duì)列
    int queue_size;               // 隊(duì)列大小
    int head, tail;               // 隊(duì)列頭尾索引
    int thread_count;             // 線程池中的線程數(shù)
    pthread_mutex_t lock;        // 鎖，保護(hù)任務(wù)隊(duì)列
    pthread_cond_t cond;         // 條件變量，喚醒工作線程
    int shutdown;                 // 是否關(guān)閉線程池
} thread_pool_t;

#include <pthread.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
typedef struct {
    void (*routine)(void *arg);  // 任務(wù)執(zhí)行的函數(shù)
    void *arg;                   // 傳遞給任務(wù)函數(shù)的參數(shù)
} task_t;
typedef struct {
    pthread_t *threads;           // 工作線程數(shù)組
    task_t *task_queue;           // 任務(wù)隊(duì)列
    int queue_size;               // 隊(duì)列大小
    int head, tail;               // 隊(duì)列頭尾索引
    int thread_count;             // 線程池中的線程數(shù)
    pthread_mutex_t lock;        // 鎖，保護(hù)任務(wù)隊(duì)列
    pthread_cond_t cond;         // 條件變量，喚醒工作線程
    int shutdown;                 // 是否關(guān)閉線程池
} thread_pool_t;
void *worker(void *arg) {
    thread_pool_t *pool = (thread_pool_t *)arg;
    while (1) {
        pthread_mutex_lock(&pool->lock);
        while (pool->head == pool->tail && !pool->shutdown) {
            pthread_cond_wait(&pool->cond, &pool->lock);  // 等待任務(wù)
        }
        // 檢查是否關(guān)閉線程池
        if (pool->shutdown) {
            pthread_mutex_unlock(&pool->lock);
            break;
        }
        task_t task = pool->task_queue[pool->head];  // 獲取任務(wù)
        pool->head = (pool->head + 1) % pool->queue_size;  // 隊(duì)列中移除任務(wù)
        pthread_mutex_unlock(&pool->lock);
        task.routine(task.arg);  // 執(zhí)行任務(wù)
    }
    pthread_exit(NULL);
}
void thread_pool_init(thread_pool_t *pool, int thread_count, int queue_size) {
    pool->threads = (pthread_t *)malloc(thread_count * sizeof(pthread_t));
    pool->task_queue = (task_t *)malloc(queue_size * sizeof(task_t));
    pool->queue_size = queue_size;
    pool->head = pool->tail = 0;
    pool->thread_count = thread_count;
    pool->shutdown = 0;
    pthread_mutex_init(&pool->lock, NULL);
    pthread_cond_init(&pool->cond, NULL);
    // 創(chuàng)建線程
    for (int i = 0; i < thread_count; i++) {
        pthread_create(&pool->threads[i], NULL, worker, pool);
    }
}

void thread_pool_add_task(thread_pool_t *pool, void (*routine)(void *), void *arg) {
    pthread_mutex_lock(&pool->lock);
    // 檢查任務(wù)隊(duì)列是否滿
    if ((pool->tail + 1) % pool->queue_size != pool->head) {
        pool->task_queue[pool->tail].routine = routine;
        pool->task_queue[pool->tail].arg = arg;
        pool->tail = (pool->tail + 1) % pool->queue_size;  // 更新隊(duì)列尾部
        pthread_cond_signal(&pool->cond);  // 喚醒一個(gè)工作線程
    }
    pthread_mutex_unlock(&pool->lock);
}

void thread_pool_destroy(thread_pool_t *pool) {
    pthread_mutex_lock(&pool->lock);
    pool->shutdown = 1;
    pthread_cond_broadcast(&pool->cond);  // 喚醒所有線程，確保線程能夠退出
    pthread_mutex_unlock(&pool->lock);
    // 等待所有線程退出
    for (int i = 0; i < pool->thread_count; i++) {
        pthread_join(pool->threads[i], NULL);
    }
    free(pool->threads);
    free(pool->task_queue);
    pthread_mutex_destroy(&pool->lock);
    pthread_cond_destroy(&pool->cond);
}

void print_hello(void *arg) {
    printf("Hello, %s!\n", (char *)arg);
}
int main() {
    thread_pool_t pool;
    thread_pool_init(&pool, 4, 10);  // 創(chuàng)建一個(gè)線程池，包含4個(gè)線程和10個(gè)任務(wù)隊(duì)列
    for (int i = 0; i < 5; i++) {
        char *name = malloc(10);
        sprintf(name, "Task %d", i + 1);
        thread_pool_add_task(&pool, print_hello, name);
    }
    sleep(1);  // 等待任務(wù)執(zhí)行
    thread_pool_destroy(&pool);  // 銷毀線程池
    return 0;
}