使用C++实现一个线程池

以下是使用C语言实现一个简单的线程池的示例代码：

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

#define MAX_THREADS 10
#define MAX_QUEUE 100

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

typedef struct {
    task_t buffer[MAX_QUEUE];
    pthread_mutex_t lock;
    int read_pos, write_pos;
    pthread_cond_t not_empty;
    pthread_cond_t not_full;
} task_queue_t;

typedef struct {
    pthread_t threads[MAX_THREADS];
    int thread_count;
    task_queue_t queue;
} thread_pool_t;

void task_queue_init(task_queue_t *queue) {
    pthread_mutex_init(&queue->lock, NULL);
    pthread_cond_init(&queue->not_empty, NULL);
    pthread_cond_init(&queue->not_full, NULL);
    queue->read_pos = 0;
    queue->write_pos = 0;
}

void task_queue_destroy(task_queue_t *queue) {
    pthread_mutex_destroy(&queue->lock);
    pthread_cond_destroy(&queue->not_empty);
    pthread_cond_destroy(&queue->not_full);
}

void task_queue_put(task_queue_t *queue, task_t task) {
    pthread_mutex_lock(&queue->lock);
    while ((queue->write_pos + 1) % MAX_QUEUE == queue->read_pos) {
        pthread_cond_wait(&queue->not_full, &queue->lock);
    }
    queue->buffer[queue->write_pos] = task;
    queue->write_pos = (queue->write_pos + 1) % MAX_QUEUE;
    pthread_cond_signal(&queue->not_empty);
    pthread_mutex_unlock(&queue->lock);
}

task_t task_queue_get(task_queue_t *queue) {
    task_t task;
    pthread_mutex_lock(&queue->lock);
    while (queue->write_pos == queue->read_pos) {
        pthread_cond_wait(&queue->not_empty, &queue->lock);
    }
    task = queue->buffer[queue->read_pos];
    queue->read_pos = (queue->read_pos + 1) % MAX_QUEUE;
    pthread_cond_signal(&queue->not_full);
    pthread_mutex_unlock(&queue->lock);
    return task;
}

void *worker_thread(void *arg) {
    thread_pool_t *pool = (thread_pool_t *)arg;
    while (1) {
        task_t task = task_queue_get(&pool->queue);
        void (*function)(void *) = task.function;
        void *argument = task.argument;
        function(argument);
    }
    return NULL;
}

void thread_pool_init(thread_pool_t *pool) {
    int i;
    pool->thread_count = 0;
    task_queue_init(&pool->queue);
    for (i = 0; i < MAX_THREADS; i++) {
        pthread_create(&pool->threads[i], NULL, worker_thread, pool);
        pool->thread_count++;
    }
}

void thread_pool_submit(thread_pool_t *pool, void (*function)(void *), void *argument) {
    task_t task = { function, argument };
    task_queue_put(&pool->queue, task);
}

void thread_pool_shutdown(thread_pool_t *pool) {
    int i;
    for (i = 0; i < pool->thread_count; i++) {
        pthread_cancel(pool->threads[i]);
    }
    task_queue_destroy(&pool->queue);
}

void *print_message(void *arg) {
    char *message = (char *)arg;
    printf("%s\n", message);
    return NULL;
}

int main() {
    thread_pool_t pool;
    thread_pool_init(&pool);
    thread_pool_submit(&pool, print_message, "Hello, world!");
    thread_pool_submit(&pool, print_message, "Goodbye, world!");
    getchar();
    thread_pool_shutdown(&pool);
    return 0;
}

该示例程序包含了以下几个核心组件：

- `task_t` 结构体：用于存储任务函数和参数。
- `task_queue_t` 结构体：用于实现任务队列，支持多线程读写操作和阻塞等待。
- `thread_pool_t` 结构体：用于管理线程池，包括线程数组和任务队列。
- `task_queue_init` 和 `task_queue_destroy` 函数：用于初始化和销毁任务队列。
- `task_queue_put` 和 `task_queue_get` 函数：用于添加和获取任务，支持阻塞等待。
- `worker_thread` 函数：用于实现工作线程的逻辑，不断从任务队列中读取任务并执行。
- `thread_pool_init`、`thread_pool_submit` 和 `thread_pool_shutdown` 函数：用于初始化、提交和销毁线程池。
- `print_message` 函数：用于测试线程池，输出一段文本。

在主函数中，我们首先初始化线程池，然后向任务队列中提交两个任务函数，最后等待用户按下 Enter 键，然后销毁线程池。当线程池被销毁时，所有工作线程都会被取消，并且任务队列也会被销毁。

需要注意的是，在实际使用中，我们可能需要添加更多的功能，例如限制任务队列的最大长度，限制线程池的最大线程数等等。此外，在实际使用中，我们还需要确保任务函数的线程安全性，并且避免出现死锁等问题。