用C语言实现线程池

线程池原理

我们使用线程的时候就去创建一个线程，这样实现起来非常简便，但是就会有一个问题：如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。
  那么有没有一种办法使得线程可以复用，就是执行完一个任务，并不被销毁，而是可以继续执行其他的任务呢？
  线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台线程。每个线程都使用默认的堆栈大小，以默认的优先级运行，并处于多线程单元中。如果某个线程在托管代码中空闲（如正在等待某个事件）, 则线程池将插入另一个辅助线程来使所有处理器保持繁忙。
  如果所有线程池线程都始终保持繁忙，但队列中包含挂起的工作，则线程池将在一段时间后创建另一个辅助线程但线程的数目永远不会超过最大值。超过最大值的线程可以排队，但他们要等到其他线程完成后才启动。

线程池的组成结构

任务队列

任务队列：存储需要处理的任务，由工作的线程来处理这些任务。
（1）通过线程池提供的 API 函数，将一个待处理的任务添加到任务队列，或者从任务队列中删除。
（2）已处理的任务会被从任务队列中删除。
（3）线程池的使用者，也就是调用线程池函数往任务队列中添加任务的线程就是生产者线程。

工作的线程

工作的线程：任务队列任务的消费者 ，N个。
（1）线程池中维护了一定数量的工作线程，他们的作用是是不停的读任务队列，从里边取出任务并处理
（2）工作的线程相当于是任务队列的消费者角色，
（3）如果任务队列为空，工作的线程将会被阻塞 (使用条件变量 / 信号量阻塞)
（4）如果阻塞之后有了新的任务，由生产者将阻塞解除，工作线程开始工作

管理者线程

管理者线程：不处理任务队列中的任务，1个。
（1）它的任务是周期性的对任务队列中的任务数量以及处于忙状态的工作线程个数进行检测。
（2）当任务过多的时候，可以适当的创建一些新的工作线程。
（3）当任务过少的时候，可以适当的销毁一些工作的线程。

参考：【用C语言实现线程池】

typedef struct Task
{
    void (*func)(void* arg);
    void* arg;
} Task;

// 线程池结构体
struct ThreadPool
{
    // 任务队列
    Task* taskQ;
    int queueCapacity;  // 容量
    int queueSize;      // 当前任务个数
    int queueFront;     // 队头 -> 取数据
    int queueRear;      // 队尾 -> 放数据

    pthread_t managerID;    // 管理者线程ID
    pthread_t* threadIDs;   // 工作的线程ID
    int minNum;             // 最小线程数量
    int maxNum;             // 最大线程数量
    int busyNum;            // 忙的线程的个数
    int liveNum;            // 存活的线程的个数
    int exitNum;            // 要销毁的线程个数
    pthread_mutex_t mutexPool;  // 锁整个的线程池
    pthread_mutex_t mutexBusy;  // 锁busyNum变量
    pthread_cond_t notFull;     // 任务队列是不是满了
    pthread_cond_t notEmpty;    // 任务队列是不是空了

    int shutdown;           // 是不是要销毁线程池, 销毁为1, 不销毁为0
};

typedef struct ThreadPool ThreadPool;

// 创建线程池并初始化
ThreadPool* threadPoolCreate(int min, int max, int queueSize);

// 销毁线程池
int threadPoolDestroy(ThreadPool* pool);

// 给线程池添加任务
void threadPoolAdd(ThreadPool* pool, void(*func)(void*), void* arg);

// 获取线程池中工作的线程的个数
int threadPoolBusyNum(ThreadPool* pool);

// 获取线程池中活着的线程的个数
int threadPoolAliveNum(ThreadPool* pool);

// 工作的线程(消费者线程)任务函数
void* worker(void* arg);

// 管理者线程任务函数
void* manager(void* arg);

// 单个线程退出
void threadExit(ThreadPool* pool);

ThreadPool* threadPoolCreate(int min, int max, int queueSize)
{
    ThreadPool* pool = (ThreadPool*)malloc(sizeof(ThreadPool));  // 很标准的写法，直接返回 线程池指针
    do {
        if (pool == NULL) {
            printf("malloc threadpool fail...\n");
            break;
        }

        pool->threadIDs = (pthread_t*)malloc(sizeof(pthread_t) * max);  // 创建线程池管理的线程数
        if (pool->threadIDs == NULL) {
            printf("malloc threadIDs fail...\n");
            break;
        }
        memset(pool->threadIDs, 0, sizeof(pthread_t) * max);
        pool->minNum = min;
        pool->maxNum = max;
        pool->busyNum = 0;
        pool->liveNum = min;  // 和最小个数相等
        pool->exitNum = 0;

        if (pthread_mutex_init(&pool->mutexPool, NULL) != 0 ||
            pthread_mutex_init(&pool->mutexBusy, NULL) != 0 ||
            pthread_cond_init(&pool->notEmpty, NULL) != 0 ||
            pthread_cond_init(&pool->notFull, NULL) != 0)  { // 这里使用了条件变量
            printf("mutex or condition init fail...\n");
            break;
        }

        // 任务队列
        pool->taskQ = (Task*)malloc(sizeof(Task) * queueSize);
        pool->queueCapacity = queueSize;
        pool->queueSize = 0;
        pool->queueFront = 0;
        pool->queueRear = 0;

        pool->shutdown = 0;

        // 创建管理者线程，note:  pthread_create 创建的线程入参为:
        // 【manager为线程处理函数，pool为线程池指针，固定写法！】
        pthread_create(&pool->managerID, NULL, manager, pool);
        for (int i = 0; i < min; ++i) {
        	// 创建工作线程
            pthread_create(&pool->threadIDs[i], NULL, worker, pool);
        }

        return pool;
    } while (0);

    // 释放资源
    if (pool && pool->threadIDs) free(pool->threadIDs);
    if (pool && pool->taskQ) free(pool->taskQ);
    if (pool) free(pool);

    return NULL;
}

int threadPoolDestroy(ThreadPool* pool)
{
    if (pool == NULL) {
        return -1;
    }

    pool->shutdown = 1;  // 关闭线程池

    pthread_join(pool->managerID, NULL);   // 等待线程结束的意思

    // 唤醒阻塞的消费者线程（为什么都要销毁线程池了，还要激活一下线程？）
    for (int i = 0; i < pool->liveNum; ++i) {
        pthread_cond_signal(&pool->notEmpty);  // pthread_cond_t notEmpty notFull 各自的作用是什么，怎么区分？
    }
   
    // 释放堆内存
    if (pool->taskQ)
        free(pool->taskQ);

    if (pool->threadIDs)
        free(pool->threadIDs);

    pthread_mutex_destroy(&pool->mutexPool);
    pthread_mutex_destroy(&pool->mutexBusy);
    pthread_cond_destroy(&pool->notEmpty);
    pthread_cond_destroy(&pool->notFull);

    free(pool);
    pool = NULL;

    return 0;
}

/* 给线程池添加任务 */
void threadPoolAdd(ThreadPool* pool, void(*func)(void*), void* arg)
{
    pthread_mutex_lock(&pool->mutexPool);
    
    while (pool->queueSize == pool->queueCapacity && !pool->shutdown) {
        // 此时队列任务满了，要阻塞生产者线程
        pthread_cond_wait(&pool->notFull, &pool->mutexPool);
    }
   
    if (pool->shutdown) {  // 若线程池停止使用了
        pthread_mutex_unlock(&pool->mutexPool);
        return;
    }
   
    // 添加任务
    pool->taskQ[pool->queueRear].function = func;
    pool->taskQ[pool->queueRear].arg = arg;
    pool->queueRear = (pool->queueRear + 1) % pool->queueCapacity;
    pool->queueSize++;

    pthread_cond_signal(&pool->notEmpty);  // 唤醒阻塞的消费者线程（因为新增了任务，所以每次都要唤醒一下）
    pthread_mutex_unlock(&pool->mutexPool);
}

int threadPoolBusyNum(ThreadPool* pool)
{
    pthread_mutex_lock(&pool->mutexBusy);
    int busyNum = pool->busyNum;
    pthread_mutex_unlock(&pool->mutexBusy);
    return busyNum;
}

int threadPoolAliveNum(ThreadPool* pool)
{
    pthread_mutex_lock(&pool->mutexPool);
    int aliveNum = pool->liveNum;
    pthread_mutex_unlock(&pool->mutexPool);
    return aliveNum;
}

void* worker(void* arg)  // 线程处理函数的入参都是这个，为 void*，传入之后再进行强制转换
{
    ThreadPool* pool = (ThreadPool*)arg;

    while (true)
    {
        pthread_mutex_lock(&pool->mutexPool);
        
        while (pool->queueSize == 0 && !pool->shutdown) { // 当前任务队列为空
            // 阻塞工作线程（任务队列为空了，就没必要让线程运行，让其处于阻塞状态）
            pthread_cond_wait(&pool->notEmpty, &pool->mutexPool);

            if (pool->exitNum > 0)  {  // 判断是不是要销毁线程（一般这个变量都是不需要的，即线程数量是固定的）
                pool->exitNum--;
                if (pool->liveNum > pool->minNum) {
                    pool->liveNum--;
                    pthread_mutex_unlock(&pool->mutexPool);
                    threadExit(pool);
                }
            }
        }

        if (pool->shutdown) {  // 判断线程池是否被关闭了
            pthread_mutex_unlock(&pool->mutexPool);
            threadExit(pool);
        }

        // 从任务队列中取出一个任务
        Task task;
        task.function = pool->taskQ[pool->queueFront].function;
        task.arg = pool->taskQ[pool->queueFront].arg;
        // 移动头结点
        pool->queueFront = (pool->queueFront + 1) % pool->queueCapacity;
        pool->queueSize--;

        // 取出任务，要再次激活任务队列（为什么是notFull？）
        pthread_cond_signal(&pool->notFull);
        pthread_mutex_unlock(&pool->mutexPool);

        printf("thread %ld start working...\n", pthread_self());
        
        pthread_mutex_lock(&pool->mutexBusy);  // 这个busyNum变量好像没啥用呢？
        pool->busyNum++;
        pthread_mutex_unlock(&pool->mutexBusy);
        task.function(task.arg);  // 执行对应的 执行函数
        free(task.arg);
        task.arg = NULL;

        printf("thread %ld end working...\n", pthread_self());
       
        pthread_mutex_lock(&pool->mutexBusy);
        pool->busyNum--;
        pthread_mutex_unlock(&pool->mutexBusy);
    }
   
    return NULL;
}

void* manager(void* arg)
{
    ThreadPool* pool = (ThreadPool*)arg;
   
    while (!pool->shutdown) {
        sleep(3); // 每隔3s检测一次

        // 取出线程池中任务的数量和当前线程的数量
        pthread_mutex_lock(&pool->mutexPool);
        int queueSize = pool->queueSize;
        int liveNum = pool->liveNum;
        pthread_mutex_unlock(&pool->mutexPool);

        // 取出忙的线程的数量
        pthread_mutex_lock(&pool->mutexBusy);
        int busyNum = pool->busyNum;
        pthread_mutex_unlock(&pool->mutexBusy);

        // 添加线程
        // 任务的个数>存活的线程个数 && 存活的线程数<最大线程数
        if (queueSize > liveNum && liveNum < pool->maxNum)
        {
            pthread_mutex_lock(&pool->mutexPool);
            int counter = 0;
            for (int i = 0; i < pool->maxNum && counter < NUMBER && pool->liveNum < pool->maxNum; ++i) {
                if (pool->threadIDs[i] == 0) {
                    pthread_create(&pool->threadIDs[i], NULL, worker, pool);
                    counter++;
                    pool->liveNum++;
                }
            }
            pthread_mutex_unlock(&pool->mutexPool);
        }
        // 销毁线程
        // 忙的线程*2 < 存活的线程数 && 存活的线程>最小线程数
        if (busyNum * 2 < liveNum && liveNum > pool->minNum)
        {
            pthread_mutex_lock(&pool->mutexPool);
            pool->exitNum = NUMBER;
            pthread_mutex_unlock(&pool->mutexPool);
            // 让工作的线程自杀
            for (int i = 0; i < NUMBER; ++i) {
                pthread_cond_signal(&pool->notEmpty);
            }
        }
    }
   
    return NULL;
}

void threadExit(ThreadPool* pool)
{
    pthread_t tid = pthread_self();
    for (int i = 0; i < pool->maxNum; ++i) {
        if (pool->threadIDs[i] == tid) {
            pool->threadIDs[i] = 0;
            printf("threadExit() called, %ld exiting...\n", tid);
            break;
        }
    }
    
    pthread_exit(NULL);
}

kimi写的，写的比上面的好多了好吧！

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

#define MAX_TASKS 100
#define POOL_SIZE 4

// 任务函数类型定义
typedef void (*task_func_t)(void*);

// 任务结构体
typedef struct task {
    task_func_t func;
    void* arg;
    struct task* next;
} task_t;

// 线程池结构体，这里面的变量都是【必要变量】
typedef struct {
    pthread_mutex_t lock;
    pthread_cond_t cond;
    task_t* task_head;  // 链表的形式，很好啊！！缺少一个queue_size变量，更下面的整合一下！
    int stop;
    int num_threads;
    pthread_t* threads;
} thread_pool_t;

// 初始化线程池
int thread_pool_init(thread_pool_t* pool, int num_threads) {
    pthread_mutex_init(&pool->lock, NULL);
    pthread_cond_init(&pool->cond, NULL);
    pool->task_head = NULL;
    pool->stop = 0;
    pool->num_threads = num_threads;
    pool->threads = malloc(sizeof(pthread_t) * num_threads);

    for (int i = 0; i < num_threads; ++i) {
        if (pthread_create(&pool->threads[i], NULL, thread_worker, (void*)pool) != 0) {
            return -1;
        }
    }
    return 0;
}

// 销毁线程池
void thread_pool_destroy(thread_pool_t* pool) {
    pool->stop = 1;
    pthread_cond_broadcast(&pool->cond);

    for (int i = 0; i < pool->num_threads; ++i) {
        pthread_join(pool->threads[i], NULL);
    }

    pthread_mutex_destroy(&pool->lock);
    pthread_cond_destroy(&pool->cond);
    free(pool->threads);
}

// 线程池工作线程函数
void* thread_worker(void* arg) {
    thread_pool_t* pool = (thread_pool_t*)arg;
    task_t* task;

    while (true) {
        pthread_mutex_lock(&pool->lock);

        while (pool->task_head == NULL && !pool->stop) {
            pthread_cond_wait(&pool->cond, &pool->lock);  // 都为空了，将线程设置为阻塞状态
        }

        if (pool->stop) {
            pthread_mutex_unlock(&pool->lock);
            break;
        }

        task = pool->task_head;
        pool->task_head = task->next;

        pthread_mutex_unlock(&pool->lock);

        if (task != NULL) {
            task->func(task->arg);
            free(task);
        }
    }

    return NULL;
}

// 添加任务到线程池
int thread_pool_add_task(thread_pool_t* pool, task_func_t func, void* arg) {
    task_t* new_task = malloc(sizeof(task_t));
    new_task->func = func;
    new_task->arg = arg;
    new_task->next = NULL;

    pthread_mutex_lock(&pool->lock);

    if (pool->task_head == NULL) {
        pool->task_head = new_task;
    } else {
        task_t* current = pool->task_head;
        while (current->next != NULL) {
            current = current->next;
        }
        current->next = new_task;
    }

    pthread_cond_signal(&pool->cond);  // 要放在锁的中间
    pthread_mutex_unlock(&pool->lock);

    return 0;
}

// 示例任务函数
void example_task(void* arg) {
    int num = *(int*)arg;
    printf("Task %d is running\n", num);
    sleep(1); // 模拟任务执行时间
}

int main() {
    thread_pool_t pool;
    if (thread_pool_init(&pool, POOL_SIZE) != 0) {
        perror("Failed to initialize thread pool");
        return EXIT_FAILURE;
    }

    int tasks[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    for (int i = 0; i < sizeof(tasks) / sizeof(tasks[0]); ++i) {
        thread_pool_add_task(&pool, example_task, &tasks[i]);
    }

    sleep(2); // 给线程池一些时间来处理任务

    thread_pool_destroy(&pool);
    printf("Thread pool has been destroyed\n");

    return EXIT_SUCCESS;
}

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

#define MAX_THREADS 5
#define MAX_QUEUE 100

typedef struct threadpool_task {
    void (*func)(void*);
    void *arg;
    struct threadpool_task *next;
} threadpool_task_t;

typedef struct {
    pthread_mutex_t lock;
    pthread_cond_t cond;
    int thread_count;
    pthread_t *threads;
    int queue_size;
    threadpool_task_t *queue_head;
    int stop;

} threadpool_t;

void threadpool_add(threadpool_t *pool, void (*func)(void *), void *arg) {
    threadpool_task_t *new_task = malloc(sizeof(threadpool_task_t));
    new_task->func = func;
    new_task->arg = arg;  // 入参
    new_task->next = NULL;

    pthread_mutex_lock(&pool->lock);
    // Add task to the queue（参考上一个 更好理解）
    threadpool_task_t **ptr = &(pool->queue_head);
    while (*ptr) {
        ptr = &((*ptr)->next);
    }
    *ptr = new_task;

    // Signal a waiting thread
    pthread_cond_signal(&pool->cond);
    pthread_mutex_unlock(&pool->lock);
}

// Thread function
void *threadpool_thread(void *arg) {
    threadpool_t *pool = (threadpool_t *)arg;
    threadpool_task_t *task;

    while (1) {
        pthread_mutex_lock(&pool->lock);
        while (!pool->stop && !pool->queue_head) {
            pthread_cond_wait(&pool->cond, &pool->lock);
        }

        if (pool->stop) {
            if (pool->queue_head == NULL) {  // 等待队列执行完
                pthread_mutex_unlock(&pool->lock);
                break;
            }
        }

        task = pool->queue_head;
        pool->queue_head = task->next;
        pthread_mutex_unlock(&pool->lock);

        if (task) {
            task->routine(task->arg);
            free(task);
        }
    }

    pool->thread_count--;
    pthread_mutex_unlock(&pool->lock);  // 这个都没锁 怎么解锁？
    return NULL;
}

// Initialize the pool
int threadpool_init(threadpool_t *pool, int num_threads) {
    pthread_mutex_init(&pool->lock, NULL);
    pthread_cond_init(&pool->cond, NULL);
    pool->threads = malloc(max_threads * sizeof(pthread_t));
    pool->thread_count = num_threads;
    pool->queue_head = NULL;
    pool->stop = 0;
    pool->thread_count = 0;

    for (int i = 0; i < num_threads; i++) {
        pthread_create(&pool->threads[i], NULL, threadpool_thread, (void *)pool);  // 要返回值判断
    }

    return 0;
}

// Destroy the pool
void threadpool_destroy(threadpool_t *pool) {
    pthread_mutex_lock(&pool->lock);  // 上面的案例没有加锁
    pool->stop = 1;
    pthread_cond_broadcast(&pool->cond);  // why?
    pthread_mutex_unlock(&pool->lock);

    for (int i = 0; i < pool->max_threads; i++) {
        pthread_join(pool->threads[i], NULL);
    }

    free(pool->threads);
    pthread_mutex_destroy(&pool->lock);
    pthread_cond_destroy(&pool->cond);
}

// Example task function
void example_task(void *arg) {
    int task_num = *(int *)arg;
    printf("Running task %d\n", task_num);
    sleep(1);
}

int main() {
    threadpool_t pool;
    threadpool_init(&pool, MAX_THREADS);

    int tasks[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    for (int i = 0; i < sizeof(tasks) / sizeof(int); i++) {
        threadpool_add(&pool, example_task, (void *)&tasks[i]);
    }

    sleep(2); // Give some time for tasks to be processed

    threadpool_destroy(&pool);
    printf("Thread pool destroyed\n");

    return 0;
}

用C语言 写多个线程池管理，线程池用数组保存
还有些问题，需要优化一下

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

#define MAX_THREAD_POOLS 5
#define MAX_THREADS_IN_POOL 5
#define TASK_QUEUE_SIZE 10

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

typedef struct threadpool {
    pthread_mutex_t lock;
    pthread_cond_t cond;
    pthread_t *threads;
    task_t *task_queue_head;
    task_t **task_queue_tail;
    int stop;
    int thread_count;
    int max_threads;
    int task_queue_size;
} threadpool_t;

typedef struct threadpool_manager {
    threadpool_t *pools;
    int pool_count;
} threadpool_manager_t;

void task_queue_init(threadpool_t *pool) {
    pool->task_queue_head = NULL;
    pool->task_queue_tail = &(pool->task_queue_head);
    pool->task_queue_size = 0;
}

void *threadpool_worker(void *arg) {
    threadpool_t *pool = (threadpool_t *)arg;
    task_t *task;

    while (1) {
        pthread_mutex_lock(&pool->lock);
        while (pool->task_queue_head == NULL && !pool->stop) {
            pthread_cond_wait(&pool->cond, &pool->lock);
        }

        if (pool->stop && pool->task_queue_head == NULL) {
            pthread_mutex_unlock(&pool->lock);
            break;
        }

        task = pool->task_queue_head;
        *(pool->task_queue_tail) = task->next;
        if (task->next == NULL) {
            pool->task_queue_tail = &(pool->task_queue_head);
        }
        pool->task_queue_head = task->next;
        pool->task_queue_size--;

        pthread_mutex_unlock(&pool->lock);

        task->function(task->argument);
        free(task);
    }

    pool->thread_count--;
    pthread_mutex_unlock(&pool->lock);
    return NULL;
}

int threadpool_create(threadpool_t *pool, int thread_count) {
    pool->max_threads = thread_count;
    pool->thread_count = 0;
    pool->stop = 0;
    pthread_mutex_init(&pool->lock, NULL);
    pthread_cond_init(&pool->cond, NULL);
    pool->threads = malloc(sizeof(pthread_t) * thread_count);

    task_queue_init(pool);

    for (int i = 0; i < thread_count; i++) {
        if (pthread_create(&pool->threads[i], NULL, threadpool_worker, pool) != 0) {
            return -1;
        }
        pool->thread_count++;
    }
    return 0;
}

int threadpool_add_task(threadpool_t *pool, void (*function)(void *), void *argument) {
    task_t *new_task = malloc(sizeof(task_t));
    new_task->function = function;
    new_task->argument = argument;
    new_task->next = NULL;

    pthread_mutex_lock(&pool->lock);

    *(pool->task_queue_tail) = new_task;
    pool->task_queue_tail = &(new_task->next);
    pool->task_queue_size++;

    pthread_cond_signal(&pool->cond);
    pthread_mutex_unlock(&pool->lock);

    return 0;
}

void threadpool_destroy(threadpool_t *pool) {
    pthread_mutex_lock(&pool->lock);
    pool->stop = 1;
    pthread_cond_broadcast(&pool->cond);
    pthread_mutex_unlock(&pool->lock);

    for (int i = 0; i < pool->max_threads; i++) {
        pthread_join(pool->threads[i], NULL);
    }

    free(pool->threads);
    pthread_mutex_destroy(&pool->lock);
    pthread_cond_destroy(&pool->cond);
}

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

int main() {
    threadpool_manager_t manager;
    manager.pools = calloc(MAX_THREAD_POOLS, sizeof(threadpool_t));
    manager.pool_count = 0;

    // Create multiple thread pools
    for (int i = 0; i < MAX_THREAD_POOLS; i++) {
        if (threadpool_create(&manager.pools[i], MAX_THREADS_IN_POOL) != 0) {
            perror("Failed to create thread pool");
            return 1;
        }
        manager.pool_count++;
    }

    // Add tasks to the thread pools
    for (int i = 0; i < 20; i++) {
        int arg = i;
        int pool_index = i % MAX_THREAD_POOLS;
        if (threadpool_add_task(&manager.pools[pool_index], example_task, &arg) != 0) {
            perror("Failed to add task");
            return 1;
        }
    }

    sleep(5); // Give some time for tasks to be processed

    // Destroy the thread pools
    for (int i = 0; i < manager.pool_count; i++) {
        threadpool_destroy(&manager.pools[i]);
    }

    free(manager.pools);
    printf("Thread pools destroyed\n");

    return 0;
}