C++多线程实现指南 |21xrx.com

C++多线程实现指南

2023-07-13 21:21:33 深夜i 10 0

C++ 多线程实现指南

return this->m_stop || !this->m_tasks.empty();

C++是一种面向对象的编程语言，它提供了许多多线程编程的功能，允许程序使用多个进程并行执行。在C++中，多线程编程非常重要，特别是在多核处理器系统中，这是提高应用程序性能的关键。

多线程编程在开发应用程序时可以提供更好的响应性能和吞吐量。这是因为，多线程应用程序可以同时执行多个任务，从而加快程序的运行速度。开发人员可以使用C++的多线程编程功能，以提高其应用程序的性能和可靠性。

下面是一些C++多线程编程的指南：

1. 创建线程

要创建一个线程，在C++中需要使用std::thread类。该类的构造函数需要指定一个函数，这个函数将在新线程中运行。

例如，下面的代码展示了如何创建一个线程，其中函数func将在新线程中运行：

#include <iostream>
#include <thread>
void func()
  std::cout << "Hello from thread!" << std::endl;
int main()
{
  // create a thread
  std::thread t(func);
  // wait for thread to finish
  t.join();
  return 0;
}

在上面的例子中，main函数在创建一个新的线程后等待该线程完成执行，以确保程序的正确执行。

2. 多线程同步

多线程应用程序中，有时需要确保多个线程之间的同步操作。例如，当多个线程访问同一共享数据时，需要使用同步机制避免数据竞争。

C++提供了一些同步原语，如互斥锁、条件变量和原子操作等，这些原语可以有效地控制多线程应用程序的并发性。

例如，下面的代码演示了如何使用互斥锁来保护共享数据：

#include <iostream>
#include <thread>
#include <mutex>
std::mutex mtx;
void func(int& val)
{
  std::lock_guard<std::mutex> lock(mtx);
  val++;
}
int main()
{
  int val = 0;
  std::thread t1(func, std::ref(val));
  std::thread t2(func, std::ref(val));
  t1.join();
  t2.join();
  std::cout << "Final value: " << val << std::endl;
  return 0;
}

在上面的例子中，每个线程都通过std::lock_guard lock(mtx)访问互斥锁mtx。这样可以确保在访问共享数据时，只有一个线程可以访问它，从而避免数据竞争。

3. 线程池

线程池是一种常用的多线程编程模式，它可以优化多线程应用程序的性能。在使用线程池时，开发人员将一组任务添加到队列中，然后在多个线程中并发执行这些任务。

C++中，也可以使用线程池来实现多线程编程。例如，下面的代码演示了如何使用线程池来执行一组任务：

#include <iostream>
#include <thread>
#include <vector>
#include <functional>
#include <future>
#include <chrono>
using Task = std::function<int()>;
class ThreadPool
{
public:
  ThreadPool(int numThreads) : m_stop(false)
  {
    for (int i = 0; i < numThreads; ++i)
    {
      m_threads.emplace_back(std::thread([this]
      {
        while (true)
        {
          Task task;
          {
            std::unique_lock<std::mutex> lock(this->m_queue_mutex);
            this->m_condition.wait(lock, [this] { return this->m_stop || !this->m_tasks.empty(); });
            if (this->m_stop && this->m_tasks.empty())
              return;
            task = std::move(this->m_tasks.front());
            this->m_tasks.pop();
          }
          task();
        }
      }));
    }
  }
  template<class F, class... Args>
  auto enqueue(F&& f, Args&&... args)->std::future<int>
  {
    using return_type = int;
    auto task = std::make_shared<std::packaged_task<return_type()>>(std::bind(std::forward<F>(f), std::forward<Args>(args)...));
    std::future<return_type> res = task->get_future();
    {
      std::unique_lock<std::mutex> lock(m_queue_mutex);
      if (m_stop)
        throw std::runtime_error("enqueue on stopped ThreadPool");
      m_tasks.emplace([task]() { (*task)(); });
    }
    m_condition.notify_one();
    return res;
  }
  ~ThreadPool()
  {
    {
      std::unique_lock<std::mutex> lock(m_queue_mutex);
      m_stop = true;
    }
    m_condition.notify_all();
    for (std::thread& thread : m_threads)
      thread.join();
  }
private:
  std::vector<std::thread> m_threads;
  std::queue<Task> m_tasks;
  std::mutex m_queue_mutex;
  std::condition_variable m_condition;
  bool m_stop;
};
int main()
{
  ThreadPool pool(4);
  std::vector<std::future<int>> results;
  for (int i = 0; i < 8; ++i)
  {
    results.emplace_back(pool.enqueue([i]()
    {
      std::cout << "Task " << i << " started" << std::endl;
      std::this_thread::sleep_for(std::chrono::seconds(1));
      std::cout << "Task " << i << " finished" << std::endl;
      return i * i;
    }));
  }
  for (auto& result : results)
    std::cout << "Result: " << result.get() << std::endl;
  return 0;
}

上面的代码演示了如何使用C++中的线程池类ThreadPool来执行一组任务。使用线程池可以避免重复创建和销毁线程的开销，从而提高多线程应用程序的性能。

综上所述，C++提供了许多多线程编程功能，包括创建线程、多线程同步和线程池等。通过学习这些多线程编程的指南，开发人员可以有效地优化其应用程序的性能和可靠性。

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

下一篇: C++编程实例：绘制菱形

评论区

相似文章