C语言线程回调函数，主线程对回调函数的注册

在C语言中，通常通过POSIX线程库(pthreads)来处理线程操作，包括创建、同步和通信等。对于线程回调函数，它是指主线程在创建一个新线程时，将某个函数作为参数传递给该线程，当这个新线程完成某些特定任务后，会自行调用这个回调函数。

当主线程需要在子线程完成后执行一些操作时，可以这样做：

1. 定义一个回调函数原型，比如 `void (*callback_function)(void *)`，这里指针类型表示可以接收任意类型的参数。
2. 在创建线程时，将回调函数的地址传递给线程。例如：

   void *thread_routine(void *arg) {
       // 子线程的任务...
       callback_function(arg); // 调用回调函数
       return NULL;
   }

   void register_callback(void (*cb)(void *)) {
       pthread_create(&thread_id, NULL, thread_routine, cb);
   }

3. 主线程调用 `register_callback` 函数时，传入希望子线程完成任务后调用的回调函数。

4. 当子线程执行完毕，如果设计得当，它会在适当的时候调用回调函数，通常是通过设置标志位或者返回值来触发。

相关问题

C语言线程回调函数，主线程对回调函数的注册，举一个完整的例子

C语言中并没有内置的线程库支持原生的线程回调函数，但是可以借助一些外部库如POSIX线程API（pthread）来实现类似的功能。在POSIX API中，我们通常通过信号量（semaphores）或者事件通知机制（例如条件变量）配合来间接达到类似回调的效果。

下面是一个简单的示例，假设有一个主函数创建了一个工作线程，并希望在工作完成后执行特定的回调函数。这里使用了条件变量作为通信机制：

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

// 假设这是你的回调函数
void callback(void* data) {
    printf("Callback function received: %s\n", (char*)data);
}

// 主线程的工作
void* worker_thread_func(void* arg) {
    // 假设arg用于传递数据到回调函数
    char* message = "Work done by worker thread";
    
    // ... 这里做你的工作

    pthread_mutex_lock(&callback_mutex); // 获取锁
    pthread_cond_signal(&callback_condition); // 设置条件变量，唤醒等待的主线程
    pthread_mutex_unlock(&callback_mutex); // 释放锁

    return NULL; // 线程结束返回NULL
}

int main() {
    pthread_t worker_thread;
    pthread_mutex_t callback_mutex = PTHREAD_MUTEX_INITIALIZER;
    pthread_cond_t callback_condition = PTHREAD_COND_INITIALIZER;

    if (pthread_create(&worker_thread, NULL, worker_thread_func, (void*)"Worker Thread")) {
        perror("Creating worker thread failed");
        exit(1);
    }

    // 等待工作线程完成，然后执行回调
    pthread_join(worker_thread, NULL);

    // 注册回调函数（这里仅是说明，实际上需要在合适的地方安排）
    pthread_mutex_lock(&callback_mutex);
    pthread_cond_wait(&callback_condition, &callback_mutex); // 阻塞直到工作完成
    callback((void*)"Callback invoked"); // 调用回调
    pthread_mutex_unlock(&callback_mutex);

    return 0;
}

C语言如何实现主线程注册回调函数，异步回调获取子线程的结果

在C语言中，由于缺乏原生的异步回调机制，我们可以利用线程池、事件循环或者是互斥量、条件变量等并发工具来实现类似功能。这里提供一种基于线程池和互斥量的例子：

首先，定义一个工作队列用于存储任务，并包含结果的位置：

typedef struct {
    void (*func)(void* result, void* user_data);
    void* result;
    void* user_data;
} Task;

struct ThreadPool {
    int pool_size;
    pthread_t threads[pool_size];
    pthread_mutex_t mutex;
    pthread_cond_t cond;
    queue<Task> tasks;
};

然后创建一个线程池并为每个任务添加回调：

void* thread_pool_worker(void* pool) {
    ThreadPool* p = (ThreadPool*)pool;
    while (!queue_empty(&p->tasks)) {
        Task task;
        pthread_mutex_lock(&p->mutex);
        if (!queue_get(&p->tasks, &task)) { // 如果队列为空，那么退出循环
            pthread_mutex_unlock(&p->mutex);
            continue;
        }
        pthread_mutex_unlock(&p->mutex);

        // 执行任务
        task.func(task.result, task.user_data);

        // 更新结果并通知主线程
        pthread_mutex_lock(&p->mutex);
        *(task.result) = ...; // 子线程的计算结果
        pthread_cond_signal(&p->cond);
        pthread_mutex_unlock(&p->mutex);
    }

    return NULL;
}

在主线程中，你可以提交任务并等待结果：

void register_callback(ThreadPool* pool, void (*cb)(void*), void* user_data) {
    Task task;
    task.func = cb;
    task.result = &user_data;
    task.user_data = user_data;
    pthread_mutex_lock(&pool->mutex);
    queue_push(&pool->tasks, task);
    if (queue_size(&pool->tasks) == 1) { // 如果队列只有一个任务，启动一个新线程
        pthread_create(&pool->threads[pool->current_thread++ % pool_size], NULL, thread_pool_worker, (void*)pool);
    }
    pthread_mutex_unlock(&pool->mutex);
    pthread_cond_wait(&pool->cond, &pool->mutex); // 等待结果
}