typedef struct thread_pool {
    struct list_head head;   //任務(wù)隊(duì)列
    int task_max; //任務(wù)隊(duì)列最大長(zhǎng)度
    int task_num; //任務(wù)隊(duì)列實(shí)際長(zhǎng)度
    int core_num; //核心線程數(shù)量
    int dyn_max; //動(dòng)態(tài)線程最大數(shù)量
    atomic_int dyn_num; //動(dòng)態(tài)線程實(shí)際數(shù)量
    pthread_t *core_th; //核心線程pthread_t數(shù)組
    pthread_t *dyn_th; //動(dòng)態(tài)線程pthread_t數(shù)組
    int status; //線程池狀態(tài)
    pthread_mutex_t mutex; //互斥鎖
    pthread_cond_t cond; //條件變量
} thread_pool_t;

thread_pool_t* thread_pool_create(int core_num, int dyn_max) {
    thread_pool_t *tp = (thread_pool_t *)malloc(sizeof(thread_pool_t));
    if (!tp) return NULL;

    pthread_mutex_init(&tp->mutex, NULL);
    pthread_cond_init(&tp->cond, NULL);
    list_head_init(&tp->head);
    tp->status = INIT_STATUS;

    tp->task_max = TASK_MAX;
    tp->task_num = 0;
    tp->dyn_max = dyn_max;
    atomic_init(&tp->dyn_num, 0);
    tp->core_num = core_num;
    tp->core_th = malloc(core_num * sizeof(pthread_t));
    for (int i = 0; i < tp->core_num; i++) { //創(chuàng)建核心線程
        thread_arg *th_arg = (thread_arg *)malloc(sizeof(thread_arg));
        *th_arg = (thread_arg) {.tp = tp, .type = CORE_THREAD, .task = NULL};
        pthread_create(&tp->core_th[i], NULL, thread_proc, (void *)th_arg);
    }

    tp->status = RUNNING_STATUS; //設(shè)置線程池為running狀態(tài)

    return tp;
}

void thread_pool_destroy_p(thread_pool_t **ptp) {
    if (!ptp) return;
    thread_pool_t *tp = *ptp;

    while(atomic_load(&tp->dyn_num)) { //等待動(dòng)態(tài)線程全部退出
        usleep(10 * 1000);
    }

    for (int i = 0; i < tp->core_num; i++) { //等待核心線程全部退出
        pthread_join(tp->core_th[i], NULL);
    }

    free(tp->core_th);
    pthread_mutex_destroy(&tp->mutex);
    pthread_cond_destroy(&tp->cond);
    tp->status = STOP_STATUS; //設(shè)置線程池為stop狀態(tài)

    free(tp);
    ptp = NULL;
    return;
}

#define INIT_STATUS (1<<0) //init狀態(tài)
#define RUNNING_STATUS (1<<1) //running狀態(tài)
#define SHUTDOWN_STATUS (1<<2) //shutdown狀態(tài)
#define STOP_STATUS (1<<3) //stop狀態(tài)

void *thread_proc(void *arg) {
    thread_arg *th_arg = (thread_arg *)arg;
    thread_pool_t *tp = th_arg->tp;
    pid_t tid = gettid();
     //動(dòng)態(tài)線程設(shè)置成分離模式，方便管理 
     if (th_arg->type == DYN_THREAD) pthread_detach(pthread_self());

    int count = 0;
    task_t *task = NULL;
    while(1) {
        if (th_arg->task) { //創(chuàng)建線程并執(zhí)行首次任務(wù)
            printf("tid:%d first process task\n", tid);
            task = th_arg->task;
            th_arg->task = NULL;
        } else {
            task = thread_get_task(tp); //從任務(wù)隊(duì)列中獲取任務(wù)并執(zhí)行
            if (!task) {
                if (tp->status != RUNNING_STATUS) break; //線程池被關(guān)閉，線程退出
                count++;
                if ((count >= 10) && (th_arg->type == DYN_THREAD)) {
                    printf("dyn thread 10s break\n");
                    break; //動(dòng)態(tài)線程空閑10秒自動(dòng)退出
                }
                continue;
            }
            count = 0;
        }
        task->cb(task->arg);
        task_freep(&task);
    }

    free(th_arg);
    if (th_arg->type == DYN_THREAD) {
        atomic_fetch_sub(&tp->dyn_num, 1);
     }
    return NULL;
}

typedef enum TASK_TYPE {
    FREE_TYPE,
    NOFREE_TYPE,
}TASK_TYPE;

typedef void (*func)(void *arg);
typedef struct task {
    struct list_head list; //隊(duì)列節(jié)點(diǎn)
    func cb; //回調(diào)函數(shù)
    void *arg; //回調(diào)函數(shù)參數(shù)
    TASK_TYPE type; //任務(wù)參數(shù)是否需要釋放
}task_t;

#define CORE_THREAD_NUM (4) //核心線程數(shù)量
#define DYN_THREAD_MAX (32) //動(dòng)態(tài)線程最大數(shù)量
#define TASK_MAX (128) //任務(wù)隊(duì)列任務(wù)最大數(shù)量

#define ENABLE_THREAD_POOL (0) //是否開(kāi)啟線程池，0：關(guān)閉 1：開(kāi)啟
#define TEST_TASK_NUM (10000) //測(cè)試任務(wù)數(shù)量
#define TASK_INTERVAL (1000) //任務(wù)產(chǎn)生間隔時(shí)間，單位：毫秒

#define TEST_TASK_TYPE (0) //任務(wù)類(lèi)型，0：CPU密集型 1：IO密集型
#define NOP_TIMES (10000000) //CPU密集型任務(wù)執(zhí)行空指令次數(shù)
#define RAND_RANGE (1 << 18) //IO密集型任務(wù)休眠時(shí)間隨機(jī)范圍，單位：毫秒

void cpu_stress() {
    for (int i = 0; i < NOP_TIMES; i++) {
        ;
    }
}

void rand_sleep() {
    srand(time(0));
    int ms = rand() & (RAND_RANGE - 1);
    usleep(ms);
}

//任務(wù)處理函數(shù)
void task_cb(void *arg) { 
#if !TEST_TASK_TYPE
    cpu_stress();
#else
    rand_sleep();
#endif
    return;
}

atomic_int running_threads;
void *thread_proc1(void *arg) {
    atomic_fetch_add(&running_threads, 1);
    pthread_detach(pthread_self());
    task_t *task = (task_t *)arg;
    task->cb(task->arg);
    free(task);
    atomic_fetch_sub(&running_threads, 1);
    return NULL;
}

int main(int argc, char *argv[]) {

#if ENABLE_THREAD_POOL
    thread_pool_t *tp = thread_pool_create(CORE_THREAD_NUM, DYN_THREAD_MAX);
    if (!tp) {
        printf("thread_pool_create error");
        return -1;
    }

    int seq = 0;
    while(1) {
        usleep(TASK_INTERVAL);
        task_t *task = task_create(task_cb, NULL, FREE_TYPE);
        if (!task) {
            printf("task create error\n");
            usleep(10 * 1000);
            continue;
        }
        int ret = thread_add_task(tp, task);
        if (ret == -1) { //任務(wù)拒絕
            task_freep(&task);
            usleep(10 * 1000);
            continue;
        }
        if (seq++ >= TEST_TASK_NUM) {
            thread_pool_exit(tp);
            thread_pool_destroy_p(&tp);
            break;
        }
    }
    printf("thread pool test done------\n");

#else
    atomic_init(&running_threads, 0);
    int seq = 0;
    int old_num = 0;
    while(1) {
        usleep(TASK_INTERVAL);
        task_t *task = task_create(task_cb, NULL, FREE_TYPE);
        if (!task) {
            printf("task create error\n");
            usleep(10 * 1000);
            continue;
        }
        pthread_t th;
        int ret = pthread_create(&th, NULL, thread_proc1, (void *)task);
        if (ret != 0) {
            free(task);
            usleep(10 * 1000);
            continue;
        }

        int num = atomic_load(&running_threads);
        if (old_num < num) {
            old_num = num;
            printf("running_threads:%d\n", num);
        }
        if (seq++ >= TEST_TASK_NUM) break;
    }
    printf("threads test done------\n");
#endif

    return 0;
}