`
aigo
  • 浏览: 2635283 次
  • 性别: Icon_minigender_1
  • 来自: 宜昌
社区版块
存档分类
最新评论

[C++11]std::mutex和std::atomic的性能测试对比(benchmark)

阅读更多

key word:std::mutex、std::atomic、benchmark、performance

 

原文作者:@玄冬Wong

 

测试案例:8个线程分别执行1250万次累加和累减,累加的最终结果为10亿,累减的最终结果为0。

 

/************************************************************************/
/*测试std::mutex和std::atomic的性能对比  */
/************************************************************************/

#include <windows.h>
#include <iostream>
#include <time.h>  
#include <thread>
#include <list> 

#include <atomic>
#include <mutex>


#define LOOP_COUNT 12500000
#define THREAD_COUNT 8

std::atomic<unsigned int>* atomic_array;

std::mutex m;
unsigned int* int_array;

void atomic_fun()
{
	for (int i = 0; i < LOOP_COUNT; i++)
	{
		atomic_array[0]++;
		atomic_array[1]--;
	}
}

void mutex_fun()
{
	for (int i = 0; i < LOOP_COUNT; i++)
	{
		{
			std::unique_lock<std::mutex> lk(m);
			int_array[0]++;
		}
		{
			std::unique_lock<std::mutex> lk(m);
			int_array[1]--;
		}
	}
}


void test(void (*func)())
{
	atomic_array = new std::atomic<unsigned int>[2];
	atomic_array[0] = 0;
	atomic_array[1] = LOOP_COUNT * THREAD_COUNT;

	int_array = new unsigned int[2];
	int_array[0] = 0;
	int_array[1] = LOOP_COUNT * THREAD_COUNT;

	std::thread** tarray = new std::thread*[THREAD_COUNT];

	clock_t start = clock();

	for (int i = 0; i < THREAD_COUNT; i++)
	{
		tarray[i] = new std::thread(func);
	}

	for (int i = 0; i < THREAD_COUNT; i++)
	{
		tarray[i]->join();
	}

	clock_t end = clock();

	printf("cost:%dms\n", end - start);


	for (int i = 0; i < THREAD_COUNT; i++)
	{
		delete tarray[i];
	}
	delete[] tarray;
}


int main(char* args, int size)
{
	//为了排除测试程序的无关因素,测试时只开启一个:blocking或者nonblocking。
	/*test(&atomic_fun);
	printf("[atomic]0:%d 1:%d\n", atomic_array[0], atomic_array[1]);*/

	test(&mutex_fun);
	printf("[mutex]0:%d 1:%d\n", int_array[0], int_array[1]);
}

 

两种接口测试分别跑了两次,结果如下

atomic测试结果

cost:5938ms

0:100000000 1:0

 

cost:5889ms

0:100000000 1:0

 

mutex测试结果

cost:10670ms

0:100000000 1:0

 

cost:11103ms

0:100000000 1:0

 

结论:atomic的性能比mutex高一倍,不过C++11中的mutex性能已经优化很好了,旧版编译器中mutex性能差不多比atomic低一个数量级。

 

测试环境:

windows 10 pro x64

VS2015企业版 update2,release x64

CPU:i7二代移动版

 

 

分享到:
评论

相关推荐

    C++11 并发指南之std::mutex详解

    在C++11中,`std::mutex`是并发编程中的基础组件,它提供了一种机制来保护共享资源免受并发访问的影响。互斥量(Mutex)确保在任何时刻只有一个线程能持有对资源的访问权,从而防止数据竞争和其他并发问题。在`...

    C++11 std::shared_ptr总结与使用示例代码详解

    C++11 std::shared_ptr总结与使用示例代码详解 std::shared_ptr是C++11中引入的一种智能指针,主要用于自动管理资源的生命周期。下面是std::shared_ptr的总结和使用示例代码详解: 一、智能指针的用途 std::...

    我们使std :: shared_mutex快10倍

    总结来说,这个案例展示了如何通过深入理解底层硬件和C++11并发特性来优化多线程程序,尤其是针对std::shared_mutex的性能提升。这不仅对于提高程序运行速度至关重要,也是并发编程领域的重要研究方向。

    C++11 并发指南五(stdcondition_variable 详解).docx

    C++11 并发指南五(std::condition_variable 详解) std::condition_variable 是 C++11 标准中 &lt;condition_variable&gt; 头文件里的一个类,用于实现条件变量的功能。条件变量是一种同步机制,允许线程在某个条件下等待...

    C++多线程封装成类使用示例

    首先,我们需要了解C++11中的`std::thread`类。`std::thread`允许我们创建和管理线程。创建一个新线程的基本步骤包括声明一个`std::thread`对象,然后通过传递一个函数或成员函数以及其参数来启动线程。下面是一个...

    std::thread 并发测试

    这个“std::thread 并发测试”项目旨在探索和评估在不同线程数量下的程序性能,并关注如何有效地同步线程以避免竞态条件和数据不一致性。 1. **最优线程数**:在多线程环境中,不是线程越多性能越好。每个线程都...

    C++11中的mutex, lock, condition variable实现分析

    C++11中的各种mutex, lock对象,实际上都是对posix的mutex,condition的封装。不过里面也有很多细节值得学习。  std::mutex  先来看下std::mutex:  包增了一个pthread_mutex_t __m_,很简单,每个函数该干嘛...

    C++高效编程:内存与性能优化(PDG)

    3. **智能指针**:`std::unique_ptr`, `std::shared_ptr`和`std::weak_ptr`是C++11引入的智能指针,用于自动管理对象的生命周期,防止内存泄漏。 4. **RAII(Resource Acquisition Is Initialization)**:资源在...

    书中的 std::thread

    C++提供了多种同步原语,如`std::mutex`(互斥锁)、`std::condition_variable`(条件变量)、`std::future`和`std::promise`(异步计算)。例如,使用`std::mutex`保护共享资源: ```cpp std::mutex m; void ...

    基于C++11实现的定时器

    C++11引入了许多新特性,如线程库(std::thread)、原子操作(std::atomic)以及更好的时间处理功能,这些都使得实现定时器变得更加便捷。在这个基于C++11的定时器实现中,我们主要会关注以下几个关键知识点: 1. *...

    每天学点C++(C++实例教程:教程+源码)thread.zip

    C++提供了多种同步原语,如`std::mutex`用于互斥锁,`std::condition_variable`用于条件变量,以及`std::atomic`类型用于原子操作。这些工具可以帮助确保在多线程环境中数据的一致性和完整性。例如,使用`std::mutex...

    每天学点C++(C++实例教程:教程+源码)多线程.zip

    C++11引入了线程安全的容器,如`std::atomic`,它们在多线程环境下提供原子操作,保证数据的一致性。 通过学习这个实例教程,你将能掌握C++中的基本多线程编程技术,并了解如何在实际项目中有效地利用多线程提升...

    C++高效编程:内存与性能优化

    在多线程编程中,合理使用并发库中的工具(如std::thread、std::mutex、std::future)和保证线程安全是多核处理器上性能提升的必要条件。 除了上述核心内容,这本书还可能涉及到一些高级主题,如代码剖析...

    c++ std thread的用法教程

    - `std--thread(线程)_傻月菇凉的博客-CSDN博客`和`C++11 mutex方便的自解锁lock_guard_萧戈的专栏-CSDN博客`这两个链接提供了更深入的`std::thread`和`std::mutex`的使用技巧和示例。 通过理解和熟练运用上述...

    c++11 实现的阻塞队列

    在 C++11 中,我们可以使用 std::mutex、std::condition_variable 和 std::queue 等标准库来实现阻塞队列。 阻塞队列的实现需要注意以下几点: 1. 线程安全:使用 std::mutex 来保护队列的读写操作,避免多线程...

    深入理解C++11:C++11新特性解析与应用(62M高清扫描版)

    线程支持库(Thread Support Library)是C++11的重要特性之一,提供了多线程编程的API,如`std::thread`、`std::mutex`和`std::future`,使开发者能够轻松编写并发程序,充分利用多核处理器的性能。 C++11还扩展了...

    C++实现线程锁

    C++11引入了`std::mutex`类来实现互斥量。在代码中,你可以使用`lock()`、`unlock()`和`std::lock_guard`来管理锁的获取和释放。`std::lock_guard`是一个智能指针,可以自动在作用域结束时解锁,防止死锁。 ```cpp ...

    C++单例日志类(标准C/C++)

    传统的懒汉式单例可能面临多线程环境下的线程安全问题,而C++11引入了`std::mutex`和`std::lock_guard`等工具,可以方便地解决这些问题。以下是一个简单的C++11单例日志类实现示例: ```cpp #include &lt;mutex&gt; #...

    安全栈表实现,C++11实现,使用atomic特性

    在实际开发中,为了提高性能,还可以考虑使用`std::atomic_flag`来实现自旋锁,或者使用`std::mutex`等同步原语来保护非原子操作的部分。此外,无锁数据结构(如无锁栈)虽然能提供更好的并发性能,但实现起来更为...

Global site tag (gtag.js) - Google Analytics