C++mutex的使用

物随心转

已于 2022-09-19 22:33:57 修改

阅读量1.4w

点赞数 13

分类专栏： C++ 文章标签： c++ java 开发语言

于 2020-08-01 17:03:28 首次发布

本文链接：https://blog.csdn.net/sinat_31608641/article/details/107733436

版权

C++ 专栏收录该内容

167 篇文章 30 订阅

订阅专栏

一、定义

C++11中提供了std::mutex互斥量，共包含四种类型：

std::mutex：最基本的mutex类。
std::recursive_mutex：递归mutex类，能多次锁定而不死锁。
std::time_mutex：定时mutex类，可以锁定一定的时间。
std::recursive_timed_mutex：定时递归mutex类。

另外，还提供了两种锁类型：

std::lock_guard：方便线程对互斥量上锁。
std::unique_lock：方便线程对互斥量上锁，但提供了更好的上锁和解锁控制。

以及相关的函数：

std::try_lock：尝试同时对多个互斥量上锁。
std::lock：可以同时对多个互斥量上锁。
std::call_once：如果多个线程需要同时调用某个函数，call_once可以保证多个线程对该函数只调用一次。

二、mutex实例

1、使用mutux

std::mutex是C++中最基本的互斥量，提供了独占所有权的特性，std::mutex提供了以下成员函数

构造函数：std::mutex不允许拷贝构造，也不允许move拷贝，最初产生的mutex对象是处于unlocked状态的。
lock()：调用线程将锁住该互斥量，线程调用该函数会发生以下3种情况：
（1）如果该互斥量当前没有被锁住，则调用线程将该互斥量锁住，直到调用unlock之前，该线程一直拥有该锁。
（2）如果当前互斥量被其他线程锁住，则当前的调用线程被阻塞住。
（3）如果当前互斥量被当前调用线程锁住，则会产生死锁,，也就是说同一个线程中不允许锁两次。
unlock()：解锁，释放对互斥量的所有权。

int g_i = 0;
mutex g_mutex;
void c()
{
	for (int i = 0; i < 3; ++i)
	{
		g_mutex.lock();
		cout <<"thread_id  " << std::this_thread::get_id() << "  "<<"全局变量g_i  " << g_i++ << endl;
		g_mutex.unlock();
	}
}

int main()
{
	thread t1(c);
	thread t2(c);

	if (t1.joinable())
		t1.join();//调用该函数会阻塞当前线程，直到该t1线程执行完成
	if (t2.joinable())
		t2.join();
return 0；
}

2、使用try_lock

try_lock()：尝试锁住互斥量，如果互斥量被其他线程占有，则当前线程也不会被阻塞，线程调用该函数会出现下面3种情况：
（1）如果当前互斥量没有被其他线程占有，则该线程锁住互斥量，直到该线程调用unlock释放互斥量。
（2）如果当前互斥量被其他线程锁住，则当前调用线程返回false，而并不会被阻塞掉。
（3）如果当前互斥量被当前调用线程锁住，则会产生死锁。

int counter = 0;
std::mutex mtx;

void func() {
	for (int i = 0; i < 1000; ++i)
	{
		if (mtx.try_lock())
		{
			++counter;
			mtx.unlock();
		}
	}
}

int main()
{
	std::thread threads[10];

	for (int i = 0; i < 10; ++i)
	{
		threads[i] = std::thread(func);
	}

	for (auto& th : threads)
	{
		th.join();
	}
	std::cout << counter << std::endl;   // 任意值
        return 0;
}

使用try_lock对counter进行控制，最终结果是不固定的。因为try_lock在其他线程占有互斥量的情况下会返回false但是不阻塞，所以会跳过一部分的++counter操作。

3、std::recursive_mutex

std::recursive_mutex与std::mutex类似，但是它能够进行多次lock，这样能够规避一些死锁问题



int counter = 0;
std::recursive_mutex mtx;
void func2()
{
    mtx.lock();
    counter++;
    cout <<"func2 thread_id  " << std::this_thread::get_id() << "  "<<"全局变量counter  " << counter << endl;
    mtx.unlock();
}
void func1()
{
    mtx.lock();
    func2();
    counter++;
    cout <<"func1 thread_id  " << std::this_thread::get_id() << "  "<<"全局变量counter  " << counter << endl;
    mtx.unlock();
}

int main()
{
	std::thread threads[10];

	for (int i = 0; i < 10; ++i)
	{
		threads[i] = std::thread(func1);
	}

	for (auto& th : threads)
	{
		th.join();
	}
	std::cout << counter << std::endl;   
        return 0;
}