Window系统下互斥锁应用

互斥锁

头文件#include<mutex> 运行在std中

例子1： 直接用mutex mutx上锁

#include<mutex>
#include<atomic>
using namespace std;

mutex mutx1;
mutex mutx2;
int globalVariable = 0;
void fun() {
	
	for(int i=0;i<10000;i++){
		mutx1.lock();
		//临界资源
		globalVariable++;
		//this_thread::sleep_for(chrono::microseconds(2));
		globalVariable--;
		mutx1.unlock();
	}
}

int main()
{
	thread  thread1(fun);
    thread  thread2(fun);
	thread1.join();
	thread2.join();
	cout << globalVariable << endl;
	system("pause");
	return 0;
}

例2 ：使用 std::lock_guard<mutex>lock(mutx);

void fun() {
	
	for(int i=0;i<10000;i++){
		std::lock_guard<mutex>lock(mutx1);
		//临界资源
		globalVariable++;
		//this_thread::sleep_for(chrono::microseconds(2));
		globalVariable--;
	}
}

lock_guard原型： 构造函数枷锁    析构函数解锁

template<class _Mutex>
	class lock_guard
	{	// class with destructor that unlocks a mutex
public:
	using mutex_type = _Mutex;

	explicit lock_guard(_Mutex& _Mtx)
		: _MyMutex(_Mtx)
		{	// construct and lock
		_MyMutex.lock();
		}

	lock_guard(_Mutex& _Mtx, adopt_lock_t)
		: _MyMutex(_Mtx)
		{	// construct but don't lock
		}

	~lock_guard() noexcept
		{	// unlock
		_MyMutex.unlock();
		}

	lock_guard(const lock_guard&) = delete;
	lock_guard& operator=(const lock_guard&) = delete;
private:
	_Mutex& _MyMutex;
	};

例2 ：使用 std::unique_lock<mutex>lock(mutx);

void fun() {
	
	for(int i=0;i<10000;i++){
		//std::lock_guard<mutex>lock(mutx1);
		std::unique_lock<mutex>lock(mutx1);
		//临界资源
		globalVariable++;
		//this_thread::sleep_for(chrono::microseconds(2));
		globalVariable--;
		mutx2.unlock();
	}
}

枷锁之后可以任何mutex解锁