多线程下值的自增方案：_InterlockedIncrement ，atomic_long ，mutex

最近学习多线程下的整数自增，很好理解：

场景：一个点击需求，用10个线程模拟10个用户同时点击，每个线程点击10 0000次，那么实际上一共是点击100 0000 次。

下面分别使用无锁（结果肯定错误）， mutex，_InterlockedIncrement， atomic 测试：

#include <iostream>  
#include <string>  
#include <atomic>
#include <thread>
#include <vector>
#include <mutex> 
using namespace std;

long click1 = 0; 

long click2= 0;

volatile long click3 = 0;

atomic_long  click4=0;  



void  Fun111(int i)
{ 
	for (int i = 0; i < 1000000; ++i)
	{
		 ++click1;
	}
}


mutex mtx;
void  Fun222(int i)
{
	for (int i = 0; i < 1000000; ++i)
	{
		mtx.lock();
		++click2;
		mtx.unlock();
	}
}


void Fun333(int i)
{
	for (int i = 0; i < 1000000; ++i)
	{
		_InterlockedIncrement(&click3);
	}
}

void Fun444(int i)
{
	for (int i = 0; i < 1000000; ++i)
	{
		// click4 = click4 +1; //错误写法

		++click4;  //atomic重载了++
		//click4++;//正确写法
	}
}


void test_withoutLock()
{
	std::vector<std::thread> ths;

	clock_t start = clock();

	for (int i = 0; i < 10; i++)
		ths.push_back(std::thread(Fun111, i));

	for (int i = 0; i < 10; i++)
		ths[i].join();

	clock_t finish = clock();

	printf("不加锁： 一共点击了%d次, 花费%d  ms \n", click1, finish - start);
}

void test_mutex()
{
	std::vector<std::thread> ths;

	clock_t start = clock();

	for (int i = 0; i < 10; i++)
		ths.push_back(std::thread(Fun222, i));

	for (int i = 0; i < 10; i++)
		ths[i].join();

	clock_t finish = clock();

	printf("mutex： 一共点击了%d次, 花费%d  ms \n", click2, finish - start);
}


void test_InterlockedIncrement()
{
	std::vector<std::thread> ths;

	clock_t start = clock();

	for (int i = 0; i < 10; i++)
		ths.push_back(std::thread(Fun333, i));

	for (int i = 0; i < 10; i++)
		ths[i].join();

	clock_t finish = clock();

	printf("InterlockedIncrement： 一共点击了%d次, 花费%d  ms \n",  click3, finish - start);
}

void test_atomic()
{
	std::vector<std::thread> ths;

	clock_t start = clock();

	for (int i = 0; i < 10; i++)
		ths.push_back(std::thread(Fun444, i));

	for (int i = 0; i < 10; i++)
		ths[i].join();

	clock_t finish = clock();

	printf("atomic： 一共点击了%d次, 花费%d  ms \n", (int)click4, finish - start);
}



int main()
{
	//不加锁方式，结果自然错误
	 test_withoutLock();


	 //mutex方式 ,性能较差
	 test_mutex();

	 //原子自增
	 test_InterlockedIncrement();

	 //atomic类型
	test_atomic();

	return 0;
}

最终结果：

多线程下值的自增方案：_InterlockedIncrement ，atomic_long ，mutex

猜你喜欢