21xrx.com
2024-11-05 12:14:59 Tuesday
登录
文章检索 我的文章 写文章
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函数对象。当我们需要在异步操作完成后执行某些操作时,可以使用回调函数来实现。这样可以提高程序的效率和并发性,并且增强程序的健壮性。

  
  

评论区

{{item['qq_nickname']}}
()
回复
回复