C++ concurrent programming: how to perform task scheduling and thread pool management?

Task scheduling and thread pool management are the keys to improving efficiency and scalability in C concurrent programming. Task scheduling: Use std::thread to create new threads. Use the join() method to join a thread. Thread pool management: Create a ThreadPool object and specify the number of threads. Add tasks using the add_task() method. Call the join() or stop() method to shut down the thread pool.

C Concurrent Programming: Task Scheduling and Thread Pool Management

Introduction

In concurrent programming, task scheduling and thread pool management are crucial to improve the efficiency and scalability of applications. This article walks you through the concepts of task scheduling in C and shows how to manage thread pools using std::thread and std::mutex from the C 11 standard.

Task Scheduling

Task scheduling involves allocating and executing asynchronous tasks. In C, you can use std::thread to create a new thread:

std::thread t([]() {
  // 执行异步任务
});

To join a thread, use the join() method:

t.join();

Thread pool management

The thread pool is a pre-created and managed collection of threads that can be used to process tasks. Using a thread pool avoids the overhead of repeatedly creating and destroying threads.

Here's how to create and manage a thread pool in C:

class ThreadPool {
public:
  ThreadPool(int num_threads) {
    for (int i = 0; i < num_threads; i++) {
      threads_.emplace_back(std::thread([this]() { this->thread_loop(); }));
    }
  }

  void thread_loop() {
    while (true) {
      std::function<void()> task;

      {
        std::lock_guard<std::mutex> lock(mtx_);
        if (tasks_.empty()) {
          continue;
        }

        task = tasks_.front();
        tasks_.pop();
      }

      task();
    }
  }

  void add_task(std::function<void()> task) {
    std::lock_guard<std::mutex> lock(mtx_);
    tasks_.push(task);
  }

  void stop() {
    std::unique_lock<std::mutex> lock(mtx_);
    stop_ = true;
  }

  ~ThreadPool() {
    stop();

    for (auto& t : threads_) {
      t.join();
    }
  }

private:
  std::vector<std::thread> threads_;
  std::queue<std::function<void()>> tasks_;
  std::mutex mtx_;
  bool stop_ = false;
};

To use a thread pool, you can perform the following steps:

1. Create a thread pool object, Specify the number of threads to create.
2. Use the add_task() method to add tasks to the thread pool.
3. Call the join() or stop() method to close the thread pool and wait for all tasks to complete.

Practical case

The following is an example of using a thread pool to perform concurrent tasks on a multi-core system:

#include <iostream>
#include <vector>
#include "thread_pool.h"

int main() {
  ThreadPool pool(4);

  std::vector<std::future<int>> futures;
  for (int i = 0; i < 10000; i++) {
    futures.push_back(pool.add_task([i]() { return i * i; }));
  }

  for (auto& f : futures) {
    std::cout << f.get() << std::endl;
  }

  return 0;
}

Conclusion

Concurrent tasks in C can be effectively managed by using std::thread and thread pools. Whether it's scientific computing on multi-core systems or web services that need to handle a large number of requests, thread scheduling and thread pool management are key to improving code efficiency and scalability.

The above is the detailed content of C++ concurrent programming: how to perform task scheduling and thread pool management?. For more information, please follow other related articles on the PHP Chinese website!