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

#define THREAD_POOL_SIZE 5

// 任務(wù)結(jié)構(gòu)體
typedef struct {
    void (*task)(void*);
    void* arg;
} Task;

// 線程池結(jié)構(gòu)體
typedef struct {
    Task* tasks; // 任務(wù)隊列
    int size; // 任務(wù)隊列大小
    int head; // 任務(wù)隊列頭指針
    int tail; // 任務(wù)隊列尾指針
    int count; // 任務(wù)隊列中任務(wù)數(shù)量
    pthread_mutex_t lock; // 互斥鎖
    pthread_cond_t not_empty; // 非空條件變量
    pthread_cond_t not_full; // 非滿條件變量
    int shutdown; // 線程池是否關(guān)閉
    pthread_t* threads; // 工作線程數(shù)組
    int thread_count; // 工作線程數(shù)量
} ThreadPool;

// 線程池單例結(jié)構(gòu)體
typedef struct {
    ThreadPool* pool; // 線程池指針
} ThreadPoolSingleton;

static ThreadPoolSingleton* instance = NULL; // 線程池單例對象指針

// 工作線程函數(shù)
void* worker(void* arg) {
    ThreadPool* pool = (ThreadPool*)arg;
    while (1) {
        pthread_mutex_lock(&pool->lock);
        while (pool->count == 0 && !pool->shutdown) {
            pthread_cond_wait(&pool->not_empty, &pool->lock);
        }
        if (pool->count == 0 && pool->shutdown) {
            pthread_mutex_unlock(&pool->lock);
            pthread_exit(NULL);
        }
        Task task = pool->tasks[pool->head];
        pool->head = (pool->head + 1) % pool->size;
        pool->count--;
        pthread_cond_signal(&pool->not_full);
        pthread_mutex_unlock(&pool->lock);
        task.task(task.arg);
    }
    return NULL;
}

// 創(chuàng)建線程池函數(shù)
ThreadPool* create_thread_pool(int thread_count, int queue_size) {
    ThreadPool* pool = (ThreadPool*)malloc(sizeof(ThreadPool));
    pool->tasks = (Task*)malloc(sizeof(Task) * queue_size);
    pool->size = queue_size;
    pool->head = 0;
    pool->tail = 0;
    pool->count = 0;
    pthread_mutex_init(&pool->lock, NULL);
    pthread_cond_init(&pool->not_empty, NULL);
    pthread_cond_init(&pool->not_full, NULL);
    pool->shutdown = 0;
    pool->threads = (pthread_t*)malloc(sizeof(pthread_t) * thread_count);
    pool->thread_count = thread_count;
    for (int i = 0; i < thread_count; i++) {
        pthread_create(&pool->threads[i], NULL, worker, pool);
    }
    return pool;
}

// 銷毀線程池函數(shù)
void destroy_thread_pool(ThreadPool* pool) {
    pthread_mutex_lock(&pool->lock);
    pool->shutdown = 1;
    pthread_mutex_unlock(&pool->lock);
    pthread_cond_broadcast(&pool->not_empty);
    for (int i = 0; i < pool->thread_count; i++) {
        pthread_join(pool->threads[i], NULL);
    }
    free(pool->threads);
    free(pool->tasks);
    pthread_mutex_destroy(&pool->lock);
    pthread_cond_destroy(&pool->not_empty);
    pthread_cond_destroy(&pool->not_full);
    free(pool);
}

// 提交任務(wù)函數(shù)
void submit_task(ThreadPool* pool, void (*task)(void*), void* arg) {
    pthread_mutex_lock(&pool->lock);
    while (pool->count == pool->size && !pool->shutdown) {
        pthread_cond_wait(&pool->not_full, &pool->lock);
    }
    if (pool->shutdown) {
        pthread_mutex_unlock(&pool->lock);
        return;
    }
    pool->tasks[pool->tail].task = task;
    pool->tasks[pool->tail].arg = arg;
    pool->tail = (pool->tail + 1) % pool->size;
    pool->count++;
    pthread_cond_signal(&pool->not_empty);
    pthread_mutex_unlock(&pool->lock);
}

// 任務(wù)函數(shù)
void task_func(void* arg) {
    int* num = (int*)arg;
    printf("task %d is running\n", *num);
    free(num);
}

// 任務(wù)包裝函數(shù)
void* task_wrapper(void* arg) {
    TaskWrapper* wrapper = (TaskWrapper*)arg;
    submit_task(wrapper->pool, wrapper->task, wrapper->arg);
    free(wrapper);
    return NULL;
}

init_instance() {
	instance = (ThreadPoolSingleton*)malloc(sizeof(ThreadPoolSingleton));
	instance->pool = create_thread_pool(THREAD_POOL_SIZE, THREAD_POOL_SIZE);
}
// 獲取線程池單例對象函數(shù)
ThreadPool* get_thread_pool_instance() {
    return instance->pool;
}

int main() {
	init_instance();	/* 程序一開始，就必須執(zhí)行。不然，與懶漢式無較大差異 */
    ThreadPool* pool = get_thread_pool_instance(); // 獲取線程池單例對象
    for (int i = 0; i < 10; i++) {
        int* num = (int*)malloc(sizeof(int));
        *num = i;
        TaskWrapper* wrapper = (TaskWrapper*)malloc(sizeof(TaskWrapper));
        wrapper->pool = pool
		wrapper->task = task_func;
		wrapper->arg = num;
		pthread_t tid;
		pthread_create(&tid, NULL, task_wrapper, wrapper); // 提交任務(wù)
	}
	sleep(1); // 等待所有任務(wù)執(zhí)行完畢
	destroy_thread_pool(pool); // 銷毀線程池
	return 0;
}

/*
該示例代碼中，使用了單例模式來創(chuàng)建線程池對象，保證了整個程序中只有一個線程池對象。
線程池中包含了任務(wù)隊列、工作線程數(shù)組、互斥鎖、條件變量等成員，通過這些成員來實現(xiàn)任務(wù)的提交和執(zhí)行。
在主函數(shù)中，提交了10個任務(wù)，每個任務(wù)都是一個簡單的打印數(shù)字的函數(shù)，最后等待所有任務(wù)執(zhí)行完畢后銷毀線程池。
*/