利用freertos的线程写一个线程池

可以通过以下步骤实现使用 FreeRTOS 的线程编写线程池：

1. 定义线程池结构体：

typedef struct {
    int num_threads; // 线程数
    TaskHandle_t *threads; // 线程句柄数组
    SemaphoreHandle_t task_sem; // 任务信号量
    SemaphoreHandle_t done_sem; // 完成信号量
    task_func_t *task_funcs; // 任务函数数组
    void **task_args; // 任务参数数组
    int *task_results; // 任务结果数组
    int next_task; // 下一个任务的索引
} thread_pool_t;

2. 初始化线程池：

void thread_pool_init(thread_pool_t *pool, int num_threads) {
    pool->num_threads = num_threads;
    pool->threads = malloc(num_threads * sizeof(TaskHandle_t));
    pool->task_funcs = malloc(num_threads * sizeof(task_func_t));
    pool->task_args = malloc(num_threads * sizeof(void *));
    pool->task_results = malloc(num_threads * sizeof(int));
    pool->next_task = 0;

    pool->task_sem = xSemaphoreCreateBinary();
    pool->done_sem = xSemaphoreCreateCounting(num_threads, 0);

    for (int i = 0; i < num_threads; i++) {
        xTaskCreatePinnedToCore(thread_pool_worker, "worker", 4096, (void *)pool, 5, &pool->threads[i], 0);
    }
}

3. 定义任务函数类型：

typedef void *(*task_func_t)(void *);

4. 定义线程池工作函数：

void thread_pool_worker(void *arg) {
    thread_pool_t *pool = (thread_pool_t *)arg;
    for (;;) {
        // 等待任务信号量
        xSemaphoreTake(pool->task_sem, portMAX_DELAY);
        
        // 获取下一个任务
        int task_index = pool->next_task++;
        
        // 执行任务
        if (task_index < pool->num_threads) {
            pool->task_results[task_index] = pool->task_funcs[task_index](pool->task_args[task_index]);
        }

        // 发送完成信号量
        xSemaphoreGive(pool->done_sem);
    }
}

5. 提交任务到线程池：

int thread_pool_submit(thread_pool_t *pool, task_func_t func, void *arg) {
    if (pool->next_task >= pool->num_threads) {
        return -1; // 线程池已满
    }

    int task_index = pool->next_task++;

    pool->task_funcs[task_index] = func;
    pool->task_args[task_index] = arg;

    // 发送任务信号量
    xSemaphoreGive(pool->task_sem);

    return task_index;
}

6. 等待线程池中所有任务完成：

void thread_pool_wait(thread_pool_t *pool) {
    for (int i = 0; i < pool->num_threads; i++) {
        xSemaphoreTake(pool->done_sem, portMAX_DELAY);
    }
}

7. 销毁线程池：

void thread_pool_destroy(thread_pool_t *pool) {
    vSemaphoreDelete(pool->task_sem);
    vSemaphoreDelete(pool->done_sem);
    for (int i = 0; i < pool->num_threads; i++) {
        vTaskDelete(pool->threads[i]);
    }
    free(pool->threads);
    free(pool->task_funcs);
    free(pool->task_args);
    free(pool->task_results);
}

这样，我们就可以使用 FreeRTOS 的线程实现一个简单的线程池。