linux 内核 创建 线程

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

#define MAX_THREADS 10

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

typedef struct {
    pthread_t *threads;
    thread_pool_task *tasks;
    int task_count;
    int shutdown;
    pthread_mutex_t lock;
    pthread_cond_t notify;
} thread_pool;

void *thread_pool_worker(void *arg) {
    thread_pool *pool = (thread_pool *)arg;
    while (1) {
        pthread_mutex_lock(&pool->lock);
        while (pool->task_count == 0 && !pool->shutdown) {
            pthread_cond_wait(&pool->notify, &pool->lock);
        }
        if (pool->shutdown) {
            pthread_mutex_unlock(&pool->lock);
            pthread_exit(NULL);
        }
        thread_pool_task task = pool->tasks[--pool->task_count];
        pthread_mutex_unlock(&pool->lock);

        (*(task.function))(task.argument);
    }
}

void thread_pool_init(thread_pool *pool, int thread_count) {
    pool->threads = malloc(sizeof(pthread_t) * thread_count);
    pool->tasks = malloc(sizeof(thread_pool_task) * 100);
    pool->task_count = 0;
    pool->shutdown = 0;
    pthread_mutex_init(&pool->lock, NULL);
    pthread_cond_init(&pool->notify, NULL);

    for (int i = 0; i < thread_count; i++) {
        pthread_create(&pool->threads[i], NULL, thread_pool_worker, pool);
    }
}

void thread_pool_add_task(thread_pool *pool, void (*function)(void *), void *argument) {
    pthread_mutex_lock(&pool->lock);
    pool->tasks[pool->task_count].function = function;
    pool->tasks[pool->task_count].argument = argument;
    pool->task_count++;
    pthread_cond_signal(&pool->notify);
    pthread_mutex_unlock(&pool->lock);
}

void thread_pool_destroy(thread_pool *pool) {
    pthread_mutex_lock(&pool->lock);
    pool->shutdown = 1;
    pthread_cond_broadcast(&pool->notify);
    pthread_mutex_unlock(&pool->lock);

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

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

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

pthread_mutex_t lock;
int shared_variable = 0;

void *thread_function(void *arg) {
    for (int i = 0; i < 100000; i++) {
        pthread_mutex_lock(&lock);
        shared_variable++;
        pthread_mutex_unlock(&lock);
    }
    return NULL;
}

int main() {
    pthread_t threads[10];
    pthread_mutex_init(&lock, NULL);

    for (int i = 0; i < 10; i++) {
        pthread_create(&threads[i], NULL, thread_function, NULL);
    }

    for (int i = 0; i < 10; i++) {
        pthread_join(threads[i], NULL);
    }

    printf("Shared variable: %d
", shared_variable);
    pthread_mutex_destroy(&lock);
    return 0;
}