C++ 框架中并发和多线程处理的性能基准测试

不同 c++++ 框架的并发和多线程性能差异显著。基准测试显示，boost.thread 和 boost.asio 在任务并发方面表现最佳，而 std::thread 和 std::async 在共享数据结构处理方面效率更高。openmp 则在同步机制测试中脱颖而出，开销最小。

C++ 框架中并发和多线程性能基准测试

简介

在现代 C++ 应用程序中，并发和多线程编程至关重要。在不同的 C++ 框架中，实现并行任务的方式各不相同。本文旨在通过一系列基准测试来比较不同框架中的并发和多线程处理的性能。

立即学习“C++免费学习笔记（深入）”；

基准测试设置

我们使用以下环境进行了基准测试：

• Intel Core i7-9700K CPU
• 32GB 内存
• Ubuntu 18.04 LTS

我们使用了以下框架：

LobeHub

LobeChat brings you the best user experience of ChatGPT, OLLaMA, Gemini, Claude

下载

• Boost.Thread 和 Boost.Asio
• std::thread 和 std::async
• OpenMP

基准测试方法

我们创建了三个基准测试来评估并发和多线程处理的性能：

• 任务并发：创建多个线程来处理简单任务，例如打印消息。
• 共享数据结构：使用多线程对共享数据结构（例如队列）进行读写。
• 同步机制：评估不同同步机制（例如锁和互斥体）的开销。

实战案例

任务并发：

#include 
#include 

void print_message(const std::string& message) {
  std::cout << message << std::endl;
}

int main() {
  std::vector threads;
  for (int i = 0; i < 10; i++) {
    threads.emplace_back(boost::thread(print_message, "Hello!"));
  }
  for (auto& thread : threads) {
    thread.join();
  }
  return 0;
}

共享数据结构：

#include 
#include 
#include 

int main() {
  boost::asio::io_service io_service;
  boost::lockfree::queue queue;

  boost::thread producer_thread([&queue, &io_service] {
    for (int i = 0; i < 1000000; i++) {
      queue.push(i);
    }
    io_service.stop();
  });

  boost::thread consumer_thread([&queue, &io_service] {
    while (true) {
      int value;
      if (queue.pop(value)) {
        std::cout << value << std::endl;
      } else if (io_service.stopped()) {
        break;
      }
    }
  });

  io_service.run();
  producer_thread.join();
  consumer_thread.join();
  return 0;
}

同步机制：

#include 
#include 
#include 
#include 
#include 

struct Counter {
  std::atomic count{0};

  void increment() {
    count++;
  }

  void decrement() {
    count--;
  }

  int get_count() {
    return count;
  }
};

int main() {
  Counter counter;
  std::mutex mutex;
  std::vector threads;

  for (int i = 0; i < 10; i++) {
    threads.emplace_back(std::thread([&] {
      for (int i = 0; i < 1000; i++) {
        mutex.lock();
        counter.increment();
        mutex.unlock();
      }
    }));
  }

  for (auto& thread : threads) {
    thread.join();
  }

  std::cout << counter.get_count() << std::endl;
  return 0;
}