c++ 不同线程中调用回调函数

在C++中，可以使用多线程来执行任务，同时也可以使用回调函数来处理任务执行后的结果。如果回调函数需要在不同的线程中被调用，需要考虑线程安全性和同步问题。

一种常见的做法是使用线程池来管理线程，每个线程都从任务队列中获取任务并执行。当任务完成后，线程将调用回调函数来处理任务执行的结果。为了确保回调函数的线程安全性，可以使用锁来保护共享资源。

以下是一个简单的示例代码：

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <queue>

using namespace std;

class ThreadPool {
public:
    ThreadPool(int numThreads) : stop(false) {
        for (int i = 0; i < numThreads; ++i) {
            threads.emplace_back([this] {
                while (true) {
                    function<void()> task;
                    {
                        unique_lock<mutex> lock(mutex_);
                        condition_.wait(lock, [this] { return stop || !tasks_.empty(); });
                        if (stop && tasks_.empty()) return;
                        task = move(tasks_.front());
                        tasks_.pop();
                    }
                    task();
                }
            });
        }
    }

    ~ThreadPool() {
        {
            unique_lock<mutex> lock(mutex_);
            stop = true;
        }
        condition_.notify_all();
        for (thread& thread : threads) {
            thread.join();
        }
    }

    template<class F>
    void enqueue(F&& f) {
        {
            unique_lock<mutex> lock(mutex_);
            tasks_.emplace(forward<F>(f));
        }
        condition_.notify_one();
    }

private:
    vector<thread> threads;
    queue<function<void()>> tasks_;
    mutex mutex_;
    condition_variable condition_;
    bool stop;
};

void callback(int result) {
    cout << "Result: " << result << endl;
}

int main() {
    ThreadPool pool(4);
    pool.enqueue([] {
        this_thread::sleep_for(chrono::seconds(1));
        return 42;
    }, callback);
    return 0;
}

在上面的示例代码中，我们使用了一个线程池来管理线程。当需要执行任务时，我们可以将任务和回调函数一起放入任务队列中。每个线程都会从任务队列中获取任务并执行，当任务完成后，线程会将结果传递给回调函数。由于回调函数可能会被不同的线程调用，我们需要使用锁来保护共享资源。