线程之路二：线程原子操作和线程CriticalSection操作

最新推荐文章于 2022-01-01 11:32:57 发布

原创最新推荐文章于 2022-01-01 11:32:57 发布 · 698 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#线程

c++成长之路专栏收录该内容

9 篇文章

订阅专栏

本文探讨线程中的原子操作和CriticalSection机制。通过实例说明原子操作如何确保线程安全，避免数据竞争问题。同时，解释CriticalSection的使用，以及线程同步中可能遇到的不一致性问题。旋转锁作为Critical Section的一种补充，将在后续讨论。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一原子操作：即是那种运行了不把这条语句执行完就不会把计算机控制权交给另一个线程控制

#include <iostream>
#include<Windows.h>
#include <process.h>

int num=0;

unsigned int __stdcall ThreadFun(PVOID pm)
{
	InterlockedIncrement((LPLONG)&num);  //原子操作
	//std::cout<<"第"<<*((int*)pm)<<"线程PID："<<GetCurrentThreadId()<<"说："<<num<<std::endl;
	return 0;
}

int main()
{
	const int n =100;
	int m =10;
	unsigned int a[n];
	HANDLE handle[n];
	while(m){
		num=0;
		for(int i=0;i<n;i++){

			handle[i] =(HANDLE)_beginthreadex(NULL,0,ThreadFun,&i,0,&a[i]);
		}
		WaitForMultipleObjects(n,handle,true,INFINITE);
		m--;
		std::cout<<num<<std::endl;
	}
	/*for(int j=0;j<n;j++)
	std::cout<<a[j]<<std::endl;*/
	system("pause");
	return 0;
}

结果如下：

这里你也许会问为什么不全是100；答案多线程；主进程不等每次while循环中的100线程执行完，就进行下一次的100个线程了，也许上一次只有56个线程执行完毕，此时num=55，而进入下一循环就会置0；此时前100次中的五十六次算白执行了，也就为什么会有大于和小于100的情况了

在每次while中不置0，代码：

#include <iostream>
#include<Windows.h>
#include <process.h>
#include <stdio.h> 

int num=0;

unsigned int __stdcall ThreadFun(PVOID pm)
{
	InterlockedIncrement((LPLONG)&num);  //原子操作
	//std::cout<<"第"<<*((int*)pm)<<"线程PID："<<GetCurrentThreadId()<<"说："<<num<<std::endl;
	return 0;
}

int main()
{
	const int n =100;
	int m =10;
	unsigned int a[n];
	HANDLE handle[n];
	while(m){
		for(int i=0;i<n;i++){

			handle[i] =(HANDLE)_beginthreadex(NULL,0,ThreadFun,&i,0,&a[i]);
		}
		WaitForMultipleObjects(n,handle,true,INFINITE);
		m--;
		std::cout<<num<<std::endl;
	}
	/*for(int j=0;j<n;j++)
	std::cout<<a[j]<<std::endl;*/
	Sleep(10000);//等待所有线程执行完毕
	std::cout<<num<<std::endl;
	system("pause");
	return 0;
}

此时结果出现1000！

不用原子操作改成num++ 会出现结果：

不一定为1000

二CriticalSection操作

#include <iostream>
#include<Windows.h>
#include <process.h>

CRITICAL_SECTION a,b;
int num;
unsigned int __stdcall ThreadFun(PVOID pm)
{
	LeaveCriticalSection(&a);
	EnterCriticalSection(&b);
	num++;
		std::cout<<*((int*)pm)<<"说："<<num<<std::endl;
	LeaveCriticalSection(&b);
	return 0;
}

int main()
{
	const int n =50;
	HANDLE handle[n];

	InitializeCriticalSection(&a);
	InitializeCriticalSection(&b);
	num = 0;
	int i=0;
	while(i<10){
		EnterCriticalSection(&a);
		handle[i] =(HANDLE)_beginthreadex(NULL,0,ThreadFun,&i,0,NULL);
		i++;
	}
	WaitForMultipleObjects(n,handle,true,INFINITE);
	system("pause");
	return 0;
}

结果为：

但此时传入的值不对，这个原因主要是主进程调用到这句话时

handle[i] =(HANDLE)_beginthreadex(NULL,0,ThreadFun,&i,0,NULL);

线程不一定在这个之后去运行函数

unsigned int __stdcall ThreadFun(PVOID pm)

这是不能同步的

介绍下旋转锁：

//等待访问这个资源，不停的假装告诉系统我正在使用这个资源
  //但是，是通过InterlockedExchange这个原子函数告诉系统的，
 //这意味着如果这个资源正被别的线程使用的时候，CPU不会让这件事变为事实
   //但是呢如果，没线程使用访问改变量的话，当前线程就得逞了。
   //看来主动一些就会有收获的，
   //接下来这个非常主动的线程将要跳出辛苦的循环请求过程享受他的成果了
   while(InterlockedExchange(&g_fResourceInUse, TRUE) == TRUE)
     Sleep(0);
   //访问刚占有的资源
 //Access the resource.

InitializeCriticalSectionAndSpinCount(&b,4000);//旋转锁 旋转4000次

其他的跟CriticalSection一样

下回合再说