linux c 线程池

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

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

#define MAX_THREADS 10
#define MAX_QUEUE 100

pthread_t threads[MAX_THREADS];
thread_pool_task_t task_queue[MAX_QUEUE];
int queue_head = 0, queue_tail = 0;
int is_running = 1;

void *thread_pool_worker(void *arg) {
    while (is_running) {
        if (queue_head != queue_tail) {
            thread_pool_task_t task = task_queue[queue_head++];
            task.function(task.argument);
        } else {
            sched_yield(); // 让出CPU时间片
        }
    }
    return NULL;
}

void thread_pool_init() {
    for (int i = 0; i < MAX_THREADS; ++i) {
        pthread_create(&threads[i], NULL, thread_pool_worker, NULL);
    }
}

void thread_pool_add_task(void (*function)(void *), void *argument) {
    task_queue[queue_tail].function = function;
    task_queue[queue_tail].argument = argument;
    queue_tail = (queue_tail + 1) % MAX_QUEUE;
}

void thread_pool_destroy() {
    is_running = 0;
    for (int i = 0; i < MAX_THREADS; ++i) {
        pthread_join(threads[i], NULL);
    }
}

// 示例任务函数
void example_task(void *arg) {
    int *num = (int *)arg;
    printf("Task %d is running.\n", *num);
}

int main() {
    thread_pool_init();

    for (int i = 0; i < 20; ++i) {
        int *num = malloc(sizeof(int));
        *num = i;
        thread_pool_add_task(example_task, num);
    }

    sleep(5); // 等待任务执行
    thread_pool_destroy();

    return 0;
}

pthread_mutex_t queue_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t queue_cond = PTHREAD_COND_INITIALIZER;

void *thread_pool_worker(void *arg) {
    while (is_running) {
        pthread_mutex_lock(&queue_mutex);
        while (queue_head == queue_tail && is_running) {
            pthread_cond_wait(&queue_cond, &queue_mutex);
        }
        if (!is_running) {
            pthread_mutex_unlock(&queue_mutex);
            break;
        }
        thread_pool_task_t task = task_queue[queue_head++];
        pthread_mutex_unlock(&queue_mutex);

        task.function(task.argument);
    }
    return NULL;
}

void thread_pool_add_task(void (*function)(void *), void *argument) {
    pthread_mutex_lock(&queue_mutex);
    task_queue[queue_tail].function = function;
    task_queue[queue_tail].argument = argument;
    queue_tail = (queue_tail + 1) % MAX_QUEUE;
    pthread_cond_signal(&queue_cond);
    pthread_mutex_unlock(&queue_mutex);
}