C++多线程回调函数实现 |21xrx.com

C++多线程回调函数实现

2023-07-02 16:02:45 深夜i -- --

C++ Multithreading Callback Function Implementation

return stopped_ || !tasks_.empty();

C++是一种面向对象的高级编程语言，支持多线程编程，可以提供更高效的计算能力。在多线程编程中，常常需要使用回调函数来实现异步回调操作。本文将介绍如何使用C++多线程回调函数实现异步操作，并且引入了lambda表达式和std::function函数对象。

C++多线程回调函数实现的核心是回调函数，回调函数是一种函数指针，用于在特定条件下执行某些操作。在C++中，回调函数可以由类成员函数、函数指针、lambda表达式和std::function函数对象等实现。我们常用的回调函数是函数指针和类成员函数指针。

在使用回调函数时，需要用到多线程实现异步操作。在多线程编程中，通常有两种方式来实现异步操作：线程池和Future和Promise。线程池是指维护一组线程，可以在需要的时候向线程池中提交任务，在空闲线程中执行任务。Future和Promise是指在一个线程中处理任务，并在另一个线程中阻塞等待结果。在本文中，我们使用线程池实现异步操作。

使用线程池实现异步操作的步骤如下：

1. 创建一个线程池，并设置线程数目。

2. 在需要异步执行的函数中，将回调函数作为参数传递给另一个线程进行执行。

3. 在另一个线程中执行回调函数，并传递结果回调用线程。

具体实现过程如下：


// 定义一个线程池类，用于异步执行任务
class ThreadPool {
public:
  explicit ThreadPool(size_t size) : stopped_(false) {
    workers_.reserve(size);
    for (size_t i = 0; i < size; ++i) {
      workers_.emplace_back([this] {
        while (true) {
          std::unique_lock<std::mutex> lock(mutex_);
          condition_.wait(lock, [this] {
            return stopped_ || !tasks_.empty();
          });
          if (stopped_ && tasks_.empty())
            return;
          auto task = std::move(tasks_.front());
          tasks_.pop();
          lock.unlock();
          task();
        }
      });
    }
  }
  ~ThreadPool() {
    {
      std::unique_lock<std::mutex> lock(mutex_);
      stopped_ = true;
    }
    condition_.notify_all();
    for (auto& worker : workers_) {
      worker.join();
    }
  }
  template <typename Task>
  void Execute(Task task) {
    std::lock_guard<std::mutex> lock(mutex_);
    tasks_.emplace(std::move(task));
    condition_.notify_one();
  }
private:
  std::vector<std::thread> workers_;
  std::queue<std::function<void()>> tasks_;
  std::mutex mutex_;
  std::condition_variable condition_;
  bool stopped_;
};
// 定义一个异步执行函数
void AsyncOperation(ThreadPool& pool, int input, std::function<void(int)> callback) {
  pool.Execute([input, callback]() {
    // 模拟长时间操作
    std::this_thread::sleep_for(std::chrono::seconds(2));
    int result = input * input;
    callback(result);
  });
}
// 定义一个回调函数
void PrintResult(int result)
  std::cout << "Result: " << result << std::endl;
int main() {
  ThreadPool pool(4);
  int input = 5;
  // 使用函数指针回调函数
  AsyncOperation(pool, input, &PrintResult);
  // 使用类成员函数指针回调函数
  class Printer {
  public:
    void Print(int result)
      std::cout << "Result: " << result << std::endl;
    
  };
  Printer printer;
  AsyncOperation(pool, input, std::bind(&Printer::Print, &printer, std::placeholders::_1));
  // 使用lambda表达式回调函数
  AsyncOperation(pool, input, [input](int result)
    std::cout << "Result: " << result << std::endl;
  );
  // 使用std::function函数对象回调函数
  std::function<void(int)> callback = [&input](int result)
    std::cout << "Result: " << result << std::endl;
  ;
  AsyncOperation(pool, input, callback);
  std::this_thread::sleep_for(std::chrono::seconds(3));
  return 0;
}

在上述代码中，我们定义了一个线程池类ThreadPool，并在其中实现了Execute函数，用于异步执行任务。我们使用std::function函数对象来定义回调函数，在AsyncOperation函数中将回调函数作为参数传递给Execute函数。在Execute函数中，将任务添加到队列中，并唤醒一个线程来执行任务。在异步操作完成后，执行回调函数，并在回调函数中返回结果。

在main函数中，我们使用了不同的方式来定义回调函数。我们将使用函数指针、类成员函数指针、lambda表达式和std::function函数对象来定义回调函数，并将回调函数作为参数传递给AsyncOperation函数进行异步操作。

在本文中，我们介绍了使用C++多线程回调函数实现异步操作的方法，并引入了lambda表达式和std::function函数对象。当我们需要在异步操作完成后执行某些操作时，可以使用回调函数来实现。这样可以提高程序的效率和并发性，并且增强程序的健壮性。

上一篇: idea打包java可执行jar包

下一篇: C++编程赛场-信息奥赛

评论区

()

相似文章