c++线程同步之‘互斥锁’回顾

互斥锁

    在多任务操作系统中，同时运行的多个任务可能都需要使用同一种资源。这个过程有点类似于，公司部门里，我在使用着打印机打印东西的同时（还没有打印完），别人刚好也在此刻使用打印机打印东西，如果不做任何处理的话，打印出来的东西肯定是错乱的。
    在线程里也有这么一把锁——互斥锁（mutex），互斥锁是一种简单的加锁的方法来控制对共享资源的访问，互斥锁只有两种状态,即上锁( lock )和解锁( unlock )。

【互斥锁的特点】：

1. 原子性：把一个互斥量锁定为一个原子操作，这意味着操作系统（或pthread函数库）保证了如果一个线程锁定了一个互斥量，没有其他线程在同一时间可以成功锁定这个互斥量；

2. 唯一性：如果一个线程锁定了一个互斥量，在它解除锁定之前，没有其他线程可以锁定这个互斥量；

3. 非繁忙等待：如果一个线程已经锁定了一个互斥量，第二个线程又试图去锁定这个互斥量，则第二个线程将被挂起（不占用任何cpu资源），直到第一个线程解除对这个互斥量的锁定为止，第二个线程则被唤醒并继续执行，同时锁定这个互斥量。

【互斥锁的操作流程如下】：

1. 在访问共享资源后临界区域前，对互斥锁进行加锁；

2. 在访问完成后释放互斥锁导上的锁。在访问完成后释放互斥锁导上的锁；

3. 对互斥锁进行加锁后，任何其他试图再次对互斥锁加锁的线程将会被阻塞，直到锁被释放。对互斥锁进行加锁后，任何其他试图再次对互斥锁加锁的线程将会被阻塞，直到锁被释放。

下面看个例子：

#include <windows.h>
#include<mutex>
#include <iostream>

using namespace std;

int number = 1;
CRITICAL_SECTION gSection;

mutex mtex;

unsigned long __stdcall ThreadProc1(void* lp)
{
	while (number < 100)
	{
		mtex.lock();
		cout << "thread 1 : " << number << endl;
		number++;
		mtex.unlock();
		Sleep(100);
	
	}
	return 0;
}

unsigned long __stdcall ThreadProc2(void* lp)
{
	while (number < 100)
	{
		mtex.lock();
		
		cout << "thread 2 : " << number << endl;
		number++;
		mtex.unlock();
		Sleep(100);

		
	}
	return 0;
}
unsigned long __stdcall ThreadProc3(void* lp)
{
	while (number < 100)
	{

		mtex.lock();
		cout << "thread 3 : " << number << endl;
		number++;
		mtex.unlock();
		Sleep(100);

	}
	return 0;
}
int main()
{

	
	HANDLE  thread1 = CreateThread(NULL, 0, ThreadProc1, NULL, 0, NULL);
	HANDLE  thread2 = CreateThread(NULL, 0, ThreadProc2, NULL, 0, NULL);
	HANDLE  thread3 = CreateThread(NULL, 0, ThreadProc3, NULL, 0, NULL);

	

	Sleep(60000);
	system("pause");

	CloseHandle(thread1); thread1 = INVALID_HANDLE_VALUE;
	CloseHandle(thread2); thread2 = INVALID_HANDLE_VALUE;
	CloseHandle(thread3); thread3 = INVALID_HANDLE_VALUE;


	return 0;
}

结果:

lock_guard与unique_lock保护共享资源

lock与unlock必须成对合理配合使用，使用不当可能会造成资源被永远锁住，甚至出现死锁（两个线程在释放它们自己的lock之前彼此等待对方的lock）。是不是想起了C++另一对儿需要配合使用的对象new与delete，若使用不当可能会造成内存泄漏等严重问题，为此C++引入了智能指针shared_ptr与unique_ptr。智能指针借用了RAII技术（Resource Acquisition Is Initialization—使用类来封装资源的分配和初始化，在构造函数中完成资源的分配和初始化，在析构函数中完成资源的清理，可以保证正确的初始化和资源释放）对普通指针进行封装，达到智能管理动态内存释放的效果。同样的，C++也针对lock与unlock引入了智能锁lock_guard与unique_lock，同样使用了RAII技术对普通锁进行封装，达到智能管理互斥锁资源释放的效果。lock_guard与unique_lock的区别如下：


    从上面两个支持的操作函数表对比来看，unique_lock功能丰富灵活得多,比如可以提前使用unlock()解锁。如果需要实现更复杂的锁策略可以用unique_lock，如果只需要基本的锁功能，优先使用更严格高效的lock_guard。

lock_guard使用例子

在std::lock_guard对象构造时，传入的mutex对象(即它所管理的mutex对象)会被当前线程锁住。在lock_guard对象被析构时，它所管理的mutex对象会自动解锁，不需要程序员手动调用lock和unlock对mutex进行上锁和解锁操作。lock_guard对象并不负责管理mutex对象的生命周期，lock_guard对象只是简化了mutex对象的上锁和解锁操作，方便线程对互斥量上锁，即在某个lock_guard对象的生命周期内，它所管理的锁对象会一直保持上锁状态；而lock_guard的生命周期结束之后，它所管理的锁对象会被解锁。程序员可以非常方便地使用lock_guard，而不用担心异常安全问题。

#include <windows.h>
#include<mutex>
#include <iostream>

using namespace std;

int number = 1;
CRITICAL_SECTION gSection;

mutex mtex;

unsigned long __stdcall ThreadProc1(void* lp)
{
	while (number < 100)
	{
	
		lock_guard<std::mutex> m(mtex);
		cout << "thread 1 : " << number << endl;
		number++;

		Sleep(100);
	
	}
	return 0;
}

unsigned long __stdcall ThreadProc2(void* lp)
{
	while (number < 100)
	{
		lock_guard<std::mutex> m(mtex);
		
		cout << "thread 2 : " << number << endl;
		number++;
		
		Sleep(100);

		
	}
	return 0;
}

int main()
{

	
	HANDLE  thread1 = CreateThread(NULL, 0, ThreadProc1, NULL, 0, NULL);
	HANDLE  thread2 = CreateThread(NULL, 0, ThreadProc2, NULL, 0, NULL);
	
	

	Sleep(60000);
	system("pause");

	CloseHandle(thread1); thread1 = INVALID_HANDLE_VALUE;
	CloseHandle(thread2); thread2 = INVALID_HANDLE_VALUE;
	

	return 0;
}

结果：

unique_lock的使用例子

类 unique_lock 是通用互斥包装器，允许延迟锁定、锁定的有时限尝试、递归锁定、所有权转移和与条件变量一同使用。
unique_lock比lock_guard使用更加灵活，功能更加强大。
使用unique_lock需要付出更多的时间、性能成本。

#include <windows.h>
#include<mutex>
#include <iostream>

using namespace std;

int number = 1;
CRITICAL_SECTION gSection;

mutex mtex;

unsigned long __stdcall ThreadProc1(void* lp)
{
	while (number < 100)
	{
	
		unique_lock<std::mutex> m(mtex);
		cout << "thread 1 : " << number << endl;
		number++;
		m.unlock();
		Sleep(100);
	
	}
	return 0;
}

unsigned long __stdcall ThreadProc2(void* lp)
{
	while (number < 100)
	{
		unique_lock<std::mutex> m(mtex);
		
		cout << "thread 2 : " << number << endl;
		number++;
		m.unlock();
		Sleep(100);

		
	}
	return 0;
}

int main()
{

	
	HANDLE  thread1 = CreateThread(NULL, 0, ThreadProc1, NULL, 0, NULL);
	HANDLE  thread2 = CreateThread(NULL, 0, ThreadProc2, NULL, 0, NULL);
	
	

	Sleep(60000);
	system("pause");

	CloseHandle(thread1); thread1 = INVALID_HANDLE_VALUE;
	CloseHandle(thread2); thread2 = INVALID_HANDLE_VALUE;
	

	return 0;
}

结果：

unique_lock和lock_guard都是管理锁的辅助类工具，都是RAII风格；它们是在定义时获得锁，在析构时释放锁。它们的主要区别在于unique_lock锁机制更加灵活，可以再需要的时候进行lock或者unlock调用，不非得是析构或者构造时。