测试 std::mutex && CRITICAL_SECTION && QMutex 三者的效率

港控/mmm° 2022-12-03 02:21 212阅读 0赞

std::mutex 标准库的互斥锁；CRITICAL\_SECTION Windows提供的临界区；QMutex Qt提供的互斥锁封装，显然，Qt封装的效率一般不如前两者。

参照这篇文章：[https://www.iteye.com/blog/aigo-1908084][https_www.iteye.com_blog_aigo-1908084]

和他的结论差不多：在旧版本编译器上（如VS2012/2013），std::mutex 比临界区更慢；在新版本编译器上（如VS2015/2017），std::mutex 的效率显著提高，特别在竞争情况下比临界区快多了。

下面是 VS2013 和 VS2017 的运行截图（x86 Release）：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmdqaWFuYm8xOTky_size_16_color_FFFFFF_t_70][]

测试代码两份：

#include <iostream>
    #include <ctime>
    #include <mutex>  
    #include <atomic>    
    #include <thread>  
    #include <list>  
    #include <functional>
    #include <Windows.h>  
    
    //表示被锁定的资源，每次加1  
    long total = 0;
    
    //win临界区
    //Windows下的Mutex和CRITICAL_SECTION,都是递归锁,
    //而Linux下的pthread_mutex,默认是非递归锁
    CRITICAL_SECTION critical;
    //互斥锁
    std::mutex mtx;
    //可递归互斥锁
    std::recursive_mutex r_mtx;
    
    void run_critical(int count)
    {
    	for (int i = 0; i < count; ++i)
    	{
    		EnterCriticalSection(&critical);
    		++total;
    		LeaveCriticalSection(&critical);
    	}
    }
    
    void run_mutex(int count)
    {
    	for (int i = 0; i < count; ++i)
    	{
    		//std::lock_guard<std::mutex> guard(mtx);
    		mtx.lock();
    		++total;
    		mtx.unlock();
    	}
    }
    
    void run_recursive_mutex(int count)
    {
    	for (int i = 0; i < count; ++i)
    	{
    		//std::lock_guard<std::recursive_mutex> guard(r_mtx);
    		r_mtx.lock();
    		++total;
    		r_mtx.unlock();
    	}
    }
    
    void run_test(std::function<void()> func, int thread_count, const char * type)
    {
    	std::list<std::thread*> threadlist;
    
    	total = 0;
    	clock_t start = clock();
    	for (int i = 0; i < thread_count; ++i)
    	{
    		std::thread *t1 = new std::thread(func);
    		threadlist.push_back(t1);
    	}
    	for (std::list<std::thread*>::const_iterator i = threadlist.begin(); i != threadlist.end(); i++)
    	{
    		(*i)->join();
    	}
    	clock_t finish = clock();
    	std::cout << std::endl << type;
    	std::cout << std::endl << "thread count:" << thread_count;
    	std::cout << std::endl << "run count:" << total;
    	std::cout << std::endl << "ms elapsed:" << finish - start << std::endl;
    
    	for (std::list<std::thread*>::const_iterator i = threadlist.begin(); i != threadlist.end(); i++)
    	{
    		delete(*i);
    	}
    }
    
    int main(int argc, char* argv[])
    {
    	InitializeCriticalSection(&critical);
    
    	const int thread_count = 4;
    	const int loop_count = 1000000;
    
    	run_test(std::bind(&run_critical, loop_count), thread_count, "CRITICAL_SECTION");
    	run_test(std::bind(&run_mutex, loop_count), thread_count, "std::mutex");
    	run_test(std::bind(&run_recursive_mutex, loop_count), thread_count, "std::recursive_mutex");
    
    	DeleteCriticalSection(&critical);
    	system("pause");
    	return 0;
    }

#include <QCoreApplication>
    #include <QMutex>
    #include <QReadWriteLock>
    #include <QDebug>
    #include <ctime>
    #include <mutex>  
    #include <atomic>    
    #include <thread>  
    #include <list>  
    #include <functional>
    #include <Windows.h>  
    
    //表示被锁定的资源，每次加1  
    long total = 0;
    
    //win临界区
    //Windows下的Mutex和CRITICAL_SECTION,都是递归锁,
    //而Linux下的pthread_mutex,默认是非递归锁
    CRITICAL_SECTION critical;
    //互斥锁
    std::mutex mtx;
    //可递归互斥锁
    std::recursive_mutex r_mtx;
    //qt互斥锁
    QMutex qtx{ QMutex::NonRecursive };//默认就是非递归
    //qt可递归互斥锁
    QMutex r_qtx{ QMutex::Recursive };
    //qt读写锁
    QReadWriteLock qrw{ QReadWriteLock::NonRecursive };//默认就是非递归
    
    void run_critical(int count)
    {
    	for (int i = 0; i < count; ++i)
    	{
    		EnterCriticalSection(&critical);
    		++total;
    		LeaveCriticalSection(&critical);
    	}
    }
    
    void run_mutex(int count)
    {
    	for (int i = 0; i < count; ++i)
    	{
    		//std::lock_guard<std::mutex> guard(mtx);
    		mtx.lock();
    		++total;
    		mtx.unlock();
    	}
    }
    
    void run_recursive_mutex(int count)
    {
    	for (int i = 0; i < count; ++i)
    	{
    		//std::lock_guard<std::recursive_mutex> guard(r_mtx);
    		r_mtx.lock();
    		++total;
    		r_mtx.unlock();
    	}
    }
    
    void run_qmutex(int count)
    {
    	for (int i = 0; i < count; ++i)
    	{
    		qtx.lock();
    		++total;
    		qtx.unlock();
    	}
    }
    
    void run_recursive_qmutex(int count)
    {
    	for (int i = 0; i < count; ++i)
    	{
    		r_qtx.lock();
    		++total;
    		r_qtx.unlock();
    	}
    }
    
    void run_qreadwritelock_write(int count)
    {
    	for (int i = 0; i < count; ++i)
    	{
    		qrw.lockForWrite();
    		++total;
    		qrw.unlock();
    	}
    }
    
    void run_qreadwritelock_read(int count)
    {
    	for (int i = 0; i < count; ++i)
    	{
    		qrw.lockForRead();
    		++total;
    		qrw.unlock();
    	}
    }
    
    void run_test(std::function<void()> func, int thread_count, const char * type)
    {
    	std::list<std::thread*> threadlist;
    
    	total = 0;
    	clock_t start = clock();
    	for (int i = 0; i < thread_count; ++i)
    	{
    		std::thread *t1 = new std::thread(func);
    		threadlist.push_back(t1);
    	}
    	for (std::list<std::thread*>::const_iterator i = threadlist.begin(); i != threadlist.end(); i++)
    	{
    		(*i)->join();
    	}
    	clock_t finish = clock();
    	qDebug() << "\n"<< type;
    	qDebug() << "thread count:" << thread_count;
    	qDebug() << "run count:" << total;
    	qDebug() << "ms elapsed:" << finish - start;
    
    	for (std::list<std::thread*>::const_iterator i = threadlist.begin(); i != threadlist.end(); i++)
    	{
    		delete(*i);
    	}
    }
    
    int main(int argc, char* argv[])
    {
    	QCoreApplication app(argc, argv);
    	InitializeCriticalSection(&critical);
    
    	const int thread_count = 4;
    	const int loop_count = 1000000;
    
    	run_test(std::bind(&run_critical, loop_count), thread_count, "CRITICAL_SECTION");
    	run_test(std::bind(&run_mutex, loop_count), thread_count, "std::mutex");
    	run_test(std::bind(&run_recursive_mutex, loop_count), thread_count, "std::recursive_mutex");
    	run_test(std::bind(&run_qmutex, loop_count), thread_count, "QMutex");
    	run_test(std::bind(&run_recursive_qmutex, loop_count), thread_count, "QMutex(recursive)");
    	run_test(std::bind(&run_qreadwritelock_write, loop_count), thread_count, "QReadWriteLock(write)");
    	run_test(std::bind(&run_qreadwritelock_read, loop_count), thread_count, "QReadWriteLock(read)");
    
    	DeleteCriticalSection(&critical);
    	return app.exec();
    }

[https_www.iteye.com_blog_aigo-1908084]: https://www.iteye.com/blog/aigo-1908084
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmdqaWFuYm8xOTky_size_16_color_FFFFFF_t_70]: /images/20221123/0e31bff026924847a3ffe5a20e68643b.png