互斥 临界区 自旋锁 排队自旋锁 MCSLOCK 性能简单测试

最新推荐文章于 2024-07-25 15:31:38 发布
最新推荐文章于 2024-07-25 15:31:38 发布
阅读量1.5k 收藏 1
点赞数
分类专栏： 无锁队列 服务器开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/woshiyuanlei/article/details/51480597
版权

VS2013


#include <windows.h>
#include <process.h>
#include <iostream>
using namespace std;
DWORD dwTest;
const DWORD dwMax = 20000000;

//#define MY_CRITICAL
//#define MY_MUTEX
#define MY_SPINLOCK


#ifdef MY_CRITICAL
    CRITICAL_SECTION g_cs;
#elif defined MY_MUTEX
    HANDLE  g_mutex;
#else 
    SHORT   g_count;
#endif

int Init()
{
#ifdef MY_CRITICAL
	InitializeCriticalSection(&g_cs);
#elif defined MY_MUTEX
	g_mutex = CreateMutex(NULL,FALSE,NULL);
	if (g_mutex)
	{
		if (ERROR_ALREADY_EXISTS == GetLastError())
		{
			cout << "only one instance can run!" << endl;
			return 0;
		}
	}
	else{cout <<"mutex is null."<<endl;return 0; }
#else 
	g_count = 0;
#endif
	return 1;
}

void Lock()
{
#ifdef MY_CRITICAL
	EnterCriticalSection(&g_cs);
#elif defined MY_MUTEX
	WaitForSingleObject(g_mutex,INFINITE);
#else 
	while(InterlockedExchange16(&g_count,1) == 1)
		Sleep(1);
#endif
}

void UnLock()
{
#ifdef MY_CRITICAL
	LeaveCriticalSection(&g_cs);
#elif defined MY_MUTEX
	ReleaseMutex(g_mutex);
#else 
	InterlockedExchange16(&g_count, 0);
#endif
}

UINT WINAPI ThreadProc(void *)
{
	while (true)
	{
		Lock();
		dwTest++;
		if (dwTest >= dwMax)
		{
			UnLock();
			return 1;
		}
		UnLock();
	}

	return 0;
}

int main()
{
	if(!Init())
		return 0;
	dwTest = 0;
#define num 2

	HANDLE hThread[num]; int i = 0;
	DWORD begin = GetTickCount();
	hThread[i++] = (HANDLE)_beginthreadex(NULL, 0, ThreadProc, NULL, 0, NULL);
	hThread[i++] = (HANDLE)_beginthreadex(NULL, 0, ThreadProc, NULL, 0, NULL);
	WaitForMultipleObjects(num, hThread,0,INFINITE);
	DWORD end = GetTickCount();

	cout << "花费的时间为: "<<end-begin<<" 毫秒"<< endl;
	system("pause");
	return 0;
}



根据我的测试结果得出简单结论(不一定很准确):

耗时    互斥 > 临界 > 自旋锁

自旋锁采用Sleep(0)时

CPU  自旋锁  > 临界 > 互斥

采用Sleep(1) 自旋锁较低，后面考虑其它方法优化自旋锁，使之空转和Sleep浪费的时间充分利用起来!!!



优化后代码如下：

<pre name="code" class="cpp">#include <windows.h>
#include <process.h>
#include <iostream>
using namespace std;
DWORD dwTest;
const DWORD dwMax = 200000000;

#define MY_CRITICAL
//#define MY_MUTEX
//#define MY_SPINLOCK


#ifdef MY_CRITICAL
CRITICAL_SECTION g_cs;
#elif defined MY_MUTEX
HANDLE  g_mutex;
#else 
DWORD   g_count;
#endif

int Init()
{
#ifdef MY_CRITICAL
	InitializeCriticalSection(&g_cs);
#elif defined MY_MUTEX
	g_mutex = CreateMutex(NULL, FALSE, NULL);
	if (g_mutex)
	{
		if (ERROR_ALREADY_EXISTS == GetLastError())
		{
			cout << "only one instance can run!" << endl;
			return 0;
		}
	}
	else{ cout << "mutex is null." << endl; return 0; }
#else 
	g_count = 0;
#endif
	return 1;
}

#ifdef MY_CRITICAL
#elif defined MY_MUTEX
#else 
void spin_lock()
{
	// 1 优点：比2指令更少
	//while (InterlockedExchange(&g_count, 1) == 1)
	//	Sleep(1);

	// 2 优点：资源被锁时，占用总线比1机会更少
	//while (InterlockedCompareExchange(&g_count, 1, 0) == 1)
	//	Sleep(1);

	// 3 结合1和2的优点(测试发现并不比1、2快。。)
	DWORD loop_count, yield_cnt, spin_count, pause_cnt;
	DWORD hold_cnt = 2;
	if (InterlockedExchange(&g_count, 1U) == 1U)
	{
		loop_count = 0;
		spin_count = 1;
		do {
			if (loop_count < hold_cnt) {
				for (pause_cnt = spin_count; pause_cnt > 0; --pause_cnt) {
					_mm_pause();        // 这是为支持超线程的 CPU 准备的切换提示
				}
				spin_count *= hold_cnt;
			}
			else {
				yield_cnt = loop_count - 1;
				if ((yield_cnt & 63) == 63) {
					Sleep(1);          // 真正的休眠, 转入内核态
				}
				else if ((yield_cnt & 3) == 3) {
					Sleep(0);          // 切换到优先级跟自己一样或更高的线程, 可以换到别的CPU核心上
				}
				else {
					if (!SwitchToThread()) {    // 让步给该线程所在的CPU核心上的别的线程,
						// 不能切换到别的CPU核心上等待的线程
						Sleep(0);      // 如果同核心上没有可切换的线程,
						// 则切到别的核心试试(只能切优先级跟自己相同或更好的)
					}
				}
			}
			loop_count++;
		} while (InterlockedCompareExchange(&g_count, 1U, 0U) == 1U);
	}
}
void spin_unlock()
{
	InterlockedExchange(&g_count, 0);
	//InterlockedCompareExchange(&g_count, 0, 1);
}
#endif
void Lock()
{
#ifdef MY_CRITICAL
	EnterCriticalSection(&g_cs);
#elif defined MY_MUTEX
	WaitForSingleObject(g_mutex, INFINITE);
#else 
	spin_lock();
#endif
}

void UnLock()
{
#ifdef MY_CRITICAL
	LeaveCriticalSection(&g_cs);
#elif defined MY_MUTEX
	ReleaseMutex(g_mutex);
#else 
	spin_unlock();
#endif
}

UINT WINAPI ThreadProc(void *)
{
	while (true)
	{
		Lock();
		dwTest++;
		if ((dwTest < 1000000 && dwTest % 10000 == 0) || (dwTest < 100000000 && dwTest % 1000000 == 0) || (dwTest % 10000000 == 0))
			cout << dwTest << endl;
		if (dwTest >= dwMax)
		{
			UnLock();
			return 1;
		}
		UnLock();
	}

	return 0;
}

int main()
{
	if (!Init())
		return 0;
	dwTest = 0;
#define num 4

	HANDLE hThread[num]; int i = 0;
	DWORD begin = GetTickCount();
	hThread[i++] = (HANDLE)_beginthreadex(NULL, 0, ThreadProc, NULL, 0, NULL);
	//SetThreadAffinityMask(hThread[i-1],i);
	hThread[i++] = (HANDLE)_beginthreadex(NULL, 0, ThreadProc, NULL, 0, NULL);
	//SetThreadAffinityMask(hThread[i - 1], i);
	hThread[i++] = (HANDLE)_beginthreadex(NULL, 0, ThreadProc, NULL, 0, NULL);
	//SetThreadAffinityMask(hThread[i - 1], i);
	hThread[i++] = (HANDLE)_beginthreadex(NULL, 0, ThreadProc, NULL, 0, NULL);
	//SetThreadAffinityMask(hThread[i - 1], i);
	WaitForMultipleObjects(num, hThread, 0, INFINITE);
	DWORD end = GetTickCount();

	cout << "花费的时间为: " << end - begin << " 毫秒" << endl;
	system("pause");
	return 0;
}


 

以上是不公平锁，即锁A锁住资源，此时B等待，然后C等待，A释放资源后，B、C都有可能获得锁资源，而不是B获得，下面介绍一种公平锁MCSLOCK：
 

运行后发现效率很低。当然还是比互斥锁好些
 

 

<pre name="code" class="cpp">#include <windows.h>
#include <process.h>
#include <iostream>
using namespace std;
#define CAS(a,b,c) (InterlockedCompareExchangePointer((volatile PVOID*)a,(PVOID)c,(PVOID)b) == b)

DWORD dwTest;
const DWORD dwMax = 200000000;
int   nTest = dwMax;
//使用公平锁 MSCLOCK
//线程节点
struct ThreadNode
{
	ThreadNode *next;
	bool       islock;
};
//线程队列
struct ThreadQueue
{
	ThreadNode *head;
};

int Init(ThreadQueue *&queue)
{
	queue = nullptr;
	queue = new ThreadQueue;
	if (!queue) return 0;
	queue->head = nullptr;
	return 1;
}

void NodeIsLock(ThreadNode *node)
{
	DWORD count = 0, loop = 10, forloop = 1, elsecount = 0, else1 = 12, else2 = 64;
	while (node->islock)
	{
		if (count < loop)
		{
			for (int i = 0; i < forloop; i++)
				_mm_pause();
			forloop *= 2;
		}
		else
		{
			elsecount++;
			if (elsecount < else1)
				Sleep(0);
			else if (elsecount < else2)
			{
				if (!SwitchToThread())
					Sleep(0);
			}
			else
				Sleep(1);
		}
		count++;
	}
}

void NodeNextIsNull(ThreadNode *node)
{
	DWORD count = 0, loop = 10, forloop = 1, elsecount = 0, else1 = 12, else2 = 64;
	while (node->next == nullptr)
	{
		if (count < loop)
		{
			for (int i = 0; i < forloop; i++)
				_mm_pause();
			forloop *= 2;
		}
		else
		{
			elsecount++;
			if (elsecount < else1)
				Sleep(0);
			else if (elsecount < else2)
			{
				if (!SwitchToThread())
					Sleep(0);
			}
			else
				Sleep(1);
		}
		count++;
	}
}

void Lock(ThreadQueue *queue, ThreadNode *node)
{
	node->next = nullptr;
	ThreadNode *tmp = node;
	ThreadNode *pre = (ThreadNode *)InterlockedExchangePointer((PVOID volatile *)&queue->head, (PVOID)tmp);
	if (pre == nullptr)  //空闲
		return;
	node->islock = true; //a
	__asm{sfence}        //写屏障 //_WriteBarrier();
	pre->next = node;    //b

	//NodeIsLock(node);
	while (node->islock)
		Sleep(0);//_mm_pause();
}

void UnLock(ThreadQueue *queue, ThreadNode *node)
{
	if (node->next == nullptr)
	{
		if (CAS(&queue->head, node, nullptr))
			return;

		//NodeNextIsNull(node);
		while (node->next == nullptr)
			Sleep(0);

	}
	node->next->islock = false;
}

UINT WINAPI ThreadProc(void *ptr)
{
	ThreadQueue *queue = (ThreadQueue *)ptr;
	ThreadNode *node = new ThreadNode;
	while (true)
	{
		Lock(queue, node);
		if (dwTest >= dwMax)
		{
			UnLock(queue, node);
			delete node;
			return 1;
		}
		dwTest++;
		if ((dwTest < 1000000 && dwTest % 10000 == 0) || (dwTest < 100000000 && dwTest % 1000000 == 0) || (dwTest % 10000000 == 0))
			cout << dwTest << endl;
		nTest--;

		UnLock(queue, node);
	}
	//delete node; //应该所有线程结束后释放
	return 0;
}

int main()
{
	ThreadQueue *queue = nullptr;
	if (!Init(queue))
		return 0;
	dwTest = 0;
#define num 4

	HANDLE hThread[num]; int i = 0;
	DWORD begin = GetTickCount();
	hThread[i++] = (HANDLE)_beginthreadex(NULL, 0, ThreadProc, queue, 0, NULL);
	//SetThreadAffinityMask(hThread[i-1],i);
	hThread[i++] = (HANDLE)_beginthreadex(NULL, 0, ThreadProc, queue, 0, NULL);
	//SetThreadAffinityMask(hThread[i - 1], i);
	hThread[i++] = (HANDLE)_beginthreadex(NULL, 0, ThreadProc, queue, 0, NULL);
	//SetThreadAffinityMask(hThread[i - 1], i);
	hThread[i++] = (HANDLE)_beginthreadex(NULL, 0, ThreadProc, queue, 0, NULL);
	//SetThreadAffinityMask(hThread[i - 1], i);
	WaitForMultipleObjects(num, hThread, 0, INFINITE);
	DWORD end = GetTickCount();

	cout << "nTest=0则锁操作是正确的.nTest=" << nTest << endl;
	cout << "花费的时间为: " << end - begin << " 毫秒" << endl;
	system("pause");
	return 0;
}
 

 

 

 

 

使用此锁，发现CPU超高！！！而在while处改成NodeIsLock和NodeNextIsNull后CPU虽然降下来了，但是运行速度很慢!!!
 

CLH LOCK也是排队自旋锁，有空可以实现一下C++般般
 

 

数组自旋锁:
 

 

#include <windows.h>
#include <process.h>
#include <iostream>
using namespace std;
#define CAS(a,b,c) (InterlockedCompareExchangePointer((volatile PVOID*)a,(PVOID)c,(PVOID)b) == b)
#define num 4

//使用数组锁
DWORD dwTest;
const DWORD dwMax = 2000000;// 200000000;
int   nTest = dwMax;
DWORD _count = 0XFFFFFFFF;
bool  _lockarr[num] = {false};

void Lock(DWORD *ptr)
{
	//DWORD ret = InterlockedIncrement(&_count);
	//DWORD index = ret % num;
	//*ptr = index;
	//__asm{sfence}
	while (!_lockarr[*ptr])
		Sleep(0);
}

void UnLock(DWORD *ptr)
{
	_lockarr[*ptr] = false;
	__asm{sfence}
	_lockarr[(*ptr + 1) % num] = true;
}

UINT WINAPI ThreadProc(void *ptr)
{
	DWORD *Ptr = (DWORD *)ptr;
	while (true)
	{
		Lock(Ptr);
		if (dwTest >= dwMax)
		{
			UnLock(Ptr);
			return 1;
		}
		dwTest++;
		if ((dwTest < 1000000 && dwTest % 10000 == 0) || (dwTest < 100000000 && dwTest % 1000000 == 0) || (dwTest % 10000000 == 0))
			cout << dwTest << endl;
		nTest--;
		UnLock(Ptr);
	}
	return 0;
}

int main()
{
	dwTest = 0;
	DWORD index[num];
	for (int i = 0; i < num; i++)
		index[i] = i;

	HANDLE hThread[num]; int i = 0;
	DWORD begin = GetTickCount();
	_lockarr[0] = true;
	hThread[i] = (HANDLE)_beginthreadex(NULL, 0, ThreadProc, &index[i], 0, NULL); i++;
	//SetThreadAffinityMask(hThread[i-1],i);
	hThread[i] = (HANDLE)_beginthreadex(NULL, 0, ThreadProc, &index[i], 0, NULL); i++;
	//SetThreadAffinityMask(hThread[i - 1], i);
	hThread[i] = (HANDLE)_beginthreadex(NULL, 0, ThreadProc, &index[i], 0, NULL); i++;
	//SetThreadAffinityMask(hThread[i - 1], i);
	hThread[i] = (HANDLE)_beginthreadex(NULL, 0, ThreadProc, &index[i], 0, NULL); i++;
	//SetThreadAffinityMask(hThread[i - 1], i);
	WaitForMultipleObjects(num, hThread, 0, INFINITE);
	DWORD end = GetTickCount();

	cout << "nTest=0则锁操作是正确的.nTest=" << nTest << endl;
	cout << "花费的时间为: " << end - begin << " 毫秒" << endl;
	system("pause");
	return 0;
}
 

 

 


                

        

        

    

  


    

      

        

            

              
                
                  woshiyuanlei
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    1
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
互斥锁 vs 自旋锁

				
			

			

				

					行者AI
				

				

					01-27
					
					766
					
				

			

		

		

			
				
本文首发于：行者AI

锁在生活中用处很直接，比如给电瓶车加锁就是防止被偷。在编程世界里，「锁」就五花八门了，它们有着各自不同的开销和应用场景。在存在数据竞争的场景，如果选对了锁，能大大提高系统性能，否则会互相拖后腿，性能急剧降低。
加锁的目的就是保证共享资源在任意时间内，只有一个线程可以访问，以此避免数据共享导致错乱的问题。最底层就是两种锁：「互斥锁」和「自旋锁」，其他高级锁，如读写锁、悲观锁、乐观锁等都是基于它们实现的。
1. 互斥锁和自旋锁：谁更轻松高效？
想知道它们谁更高效，要先了解它们在做同一件.

			
		

	



                

              
                



	

		

			

				
					
自旋锁和互斥锁区别

				
			

			

				

					Zhanganliu的博客
				

				

					01-08
					
					1470
					
				

			

		

		

			
				
POSIX threads(简称Pthreads)是在多核平台上进行并行编程的一套常用的API。线程同步(Thread Synchronization)是并行编程中非常重要的通讯手段，其中最典型的应用就是用Pthreads提供的锁机制(lock)来对多个线程之间共 享的临界区(Critical Section)进行保护(另一种常用的同步机制是barrier)。
Pthreads提供了多种锁机制：
...

			
		

	



                


  
              

                


	

		

			

				
					
自旋锁试验

				
			

			

				

					weixin_33797791的博客
				

				

					06-29
					
					159
					
				

			

		

		

			
				
#include <windows.h>
#include <stdio.h>

typedef ULONG_PTR KSPIN_LOCK, *PKSPIN_LOCK;

VOID WINAPI
KeInitializeSpinLock(
					 IN PKSPIN_LOCK  SpinLock
					 )
{
	*SpinLock = 0;
...

			
		

	





	

		

			

				
					
数据结构与算法-插入排序

					
最新发布

				
			

			

				

					菜鸟小码的博客
				

				

					07-25
					
					1102
					
				

			

		

		

			
				
插入排序是一种简单直观的排序算法，它的工作原理类似于人们整理手中的一叠卡片。该算法通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常使用in-place排序（即只需用到O(1)的额外空间），其时间复杂度为O(n^2)，其中n是待排序数组的长度。

			
		

	



		

			
		



	

		

			

				
					
linux 信号量 自旋锁 测试 实验,实验二 并发与阻塞

				
			

			

				

					weixin_39581652的博客
				

				

					05-12
					
					128
					
				

			

		

		

			
				
实验二   阻塞与并发实验一、实验目的：1、掌握linux驱动对并发的处理，熟悉信号量，自旋锁，原子操作等的使用。2、掌握linux驱动对阻塞的处理，熟悉等待队列的使用。二、实验设备：友善之臂4412开发板、学生自带笔记本、USB转串口线、电源、网线。三、 实验地点及时间地点：A2-303a时间：教学周第四周四、实验内容：1、在ARM开发板上面，在驱动程序中利用自旋锁，编写程序，并进行测试验证所学...

			
		

	





	

		

			

				
					
linux 信号量 自旋锁 测试 实验,「正点原子Linux连载」第四十八章Linux并发与竞争实验...

				
			

			

				

					weixin_29086203的博客
				

				

					05-12
					
					241
					
				

			

		

		

			
				
1)实验平台：正点原子Linux开发板2)摘自《正点原子I.MX6U嵌入式Linux驱动开发指南》关注官方微信号公众号，获取更多资料：正点原子第四十八章Linux并发与竞争实验在上一章中我们学习了Linux下的并发与竞争，并且学习了四种常用的处理并发和竞争的机制：原子操作、自旋锁、信号量和互斥体。本章我们就通过四个实验来学习如何在驱动中使用这四种机制。48.1 原子操作实验本实验对应的例程路径为：...

			
		

	





	

		

			

				
					
linux内核mutex互斥锁测试

				
			

			

				

					yongjong的专栏
				

				

					08-10
					
					526
					
				

			

		

		

			
				
描述：启动两个内核线程，这两个内核线程都加锁互斥锁对同一个静态全局变量镜像访问。OS版本：openEuler 22.03 LTS。测试结果：两个内核线程交替打印静态全局变量。

			
		

	





	

		

			

				
					
信号量、互斥体和自旋锁的区别

				
			

			

				

					07-21
				

			

		

		

			
				
 - **自旋锁**绝对要避免用来保护包含可能引起阻塞代码的临界区，因为阻塞意味着要进行进程的切换，这可能导致死锁。  5. **锁的占用**：  - 在占用**信号量**的同时不能占用**自旋锁**，因为在等待信号量时可能会...

			
		

	





	

		

			

				
					
利用C++11原子量如何实现自旋锁详解

				
			

			

				

					12-26
				

			

		

		

			
				
实际上许多其他类型的锁在底层使用了自旋锁实现，例如多数互斥锁在试图获取锁的时候会先自旋一小段时间，然后才会休眠。如果在持锁时间很长的场景下使用自旋锁，则会导致CPU在这个线程的时间片用尽之前一直消耗在无...

			
		

	





	

		

			

				
					
自定义自旋锁测试，理解自旋锁

				
			

			

				

					weixin_45931215的博客
				

				

					08-03
					
					213
					
				

			

		

		

			
				
自旋锁就是在对资源进行获取时，资源已经被占用，无法立即获取，所以一直自旋，循环尝试获取锁，等到其它线程将锁释放，才会获得锁。
代码写一个自旋锁
public class Zixuansuo {

    AtomicReference<Thread> atomicReference = new AtomicReference();

    //加锁
    public void dolock(){
        Thread thread = Thread.currentThread();

			
		

	





	

		

			

				
					
【mutex、读写锁、自旋锁、信号量以及RCU的性能测试】

				
			

			

				

					lzwtty的博客
				

				

					07-10
					
					592
					
				

			

		

		

			
				
自旋锁特点 循环等待等  力度很小 用于链表头指针改变等情况

mutex 加锁时线程休眠一会看一下 可用于大部分情况

读写锁 读写都要判断 加锁复杂 不推荐使用

信号量 pv操作 比mutex低一点

rcu 读写锁变种 read copy update 可以代替读写锁情况...

			
		

	





	

		

			

				
					
「并发原理专题」AQS的技术体系之CLH、MCS锁的原理及实现，java架构和java开发

				
			

			

				

					m0_64205605的博客
				

				

					11-18
					
					265
					
				

			

		

		

			
				
在SMP架构下，CLH更具有优势。


在NUMA架构下，如果当前节点与前驱节点不在同一CPU模块下，跨CPU模块会带来额外的系统开销，而MCS锁更适用于NUMA架构。


加锁逻辑
1.获取当前线程的锁节点，如果为空，则进行初始化；
2.同步方法获取链表的尾节点，并将当前节点置为尾节点，此时原来的尾节点为当前节点的前置节点。
3.如果尾节点为空，表示当前节点是第一个节点，直接加锁成功。

如果尾节点不为空，则基于前置节点的锁值（locked==true）进行自旋，直到前置节点的锁值变为false。
...

			
		

	





	

		

			

				
					
无锁队列、自旋锁队列、互斥锁队列性能对比测试

				
			

			

				

					weixin_43827934的博客
				

				

					07-31
					
					2540
					
				

			

		

		

			
				
介绍
无锁队列
先大致介绍一下无锁队列。无锁队列的根本是CAS函数——CompareAndSwap，即比较并交换，函数功能可以用C++函数来说明：
int compare_and_swap (int* reg, int oldval, int newval)
{
  int old_reg_val = *reg;
  if (old_reg_val == oldval)
     *reg = n...

			
		

	





	

		

			

				
					
sysbench测试互斥锁参数详解

				
			

			

				

					qq_43012789的博客
				

				

					04-12
					
					435
					
				

			

		

		

			
				
测试多核同步性能开销时，使用了sysbench来进行互斥锁开销测试。下面是互斥锁开销测试的核心代码。https://github.com/akopytov/sysbench/blob/master/src/tests/mutex/sb_mutex.c


sb_event_t mutex_next_event(int thread_id)
{
  sb_event_t         sb_req;
  sb_mutex_request_t   *mutex_req = &sb_req.u.mute

			
		

	





	

		

			

				
					
关键代码段(Critical Sections) 和自旋锁(Spinlocks)

				
			

			

				

					weixin_33918114的博客
				

				

					09-29
					
					276
					
				

			

		

		

			
				
写在前面：今天一哥们问我，windows的临界代码是自旋还是等待，当时想了想应该是等待，后来翻了一下《Windows via C/C++》，发现还有点小意思。总结一下先。关键代码段是指一个小代码段，在代码能够执行前，它必须独占对某些共享资源的访问权。这是让若干行代码能够“以原子操作方式”来使用资源的一种方法。所谓原子操作方式，是指该代码知道没有别的线程要访问该资源。当然，系统仍然能够抑制你的线程的...

			
		

	





	

		

			

				
					
【锁】无锁队列、自旋锁队列、互斥锁队列性能对比测试

				
			

			

				

					小鱼菜鸟的博客
				

				

					09-09
					
					131
					
				

			

		

		

			
				
介绍 
无锁队列 
先大致介绍一下无锁队列。无锁队列的根本是CAS函数——CompareAndSwap，即比较并交换，函数功能可以用C++函数来说明： 
int compare_and_swap (int* reg, int oldval, int newval)
{
  int old_reg_val = *reg;
  if (old_reg_val...

			
		

	





	

		

			

				
					
Linux自旋锁和互斥锁的实现

				
			

			

				

					cpongo5
				

				

					10-29
					
					364
					
				

			

		

		

			
				
自旋锁（spin  lock）应用在多处理器环境中。如果内核控制路径发现自旋锁“开着”，就获取锁并继续自己的执行。相反，如果内核控制路径发现锁由运行在另一个CPU上的内核控制路径“锁 着”，就在周围“旋转”，反复执行一条紧凑的循环指令，直到锁被释放。自旋锁的循环指令表示“忙等”。即使等待的内核控制路径无事可做（除了浪费时间），它也在CPU上保持运行。不过，自旋锁通常非常方便，因为很多内核资源只锁1...

			
		

	





	

		

			

				
					
探索操作系统同步与互斥：自旋锁与临界区实战

				
			

			

				

					
				

			

		

		

			
				
使用锁（如自旋锁）来管理临界区，确保在任何时候只有一个进程能够进入，从而避免数据竞争和并发错误。学习如何正确地使用锁进入临界区，是实现并发控制中必不可少的技能。  实验过程中，通过阅读和分析`spin_lock`...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值