4.C++多线程-- unique_lock（类模板）

1.unique_lock

1. unique_lock<mutex> myUniLock(myMutex); 完全可以取代lock_guard

2. unique_lock 也可以使用----std::adopt_lock

3.使用adopt_lock，之前要先使用lock.

4.std::chrono::milliseconds my_sleepTime(20000)//20000毫秒

       std::this_thread::sleep_for(my_sleep);// 开始休息20秒

关键词1：try_to_lock

• 尝试用mutex的lock()去锁定这个mutex，但如果没有锁定成功，会立即返回，不会阻塞在那里；
• 使用try_to_lock的原因是防止其他的线程锁定mutex太长时间，导致本线程一直阻塞在lock这个地方
• 前提：不能提前lock();
• owns_lock()方法判断是否拿到锁，如拿到返回true

关键词2：defer_lock

• 如果没有第二个参数就对mutex进行加锁，加上defer_lock是始化了一个没有加锁的mutex
• 不给它加锁的目的是以后可以调用unique_lock的一些方法
• 前提：不能提前lock
• 不用自己unlock，有点类似智能指针；当然也可以自己提前解锁

 关键词3：try_lock()：尝试给互斥量加锁
如果拿不到锁，返回false，否则返回true。

关键词4：release()

 2.总结

adopt_lock：

使用之前先lock,不能自己unlock

my_mutex.lock();
unique_lock<mutex> myUniLock(my_mutex,adopt_lock);
{	//my_mutex.lock();
    my_list.push_back(i);
	cout << "插入元素：" << i << endl;
	//my_mutex.unlock();
}

 try_to_lock 

使用之前不能先lock, try_to_lock会自己先尝试进行加锁。如果不能加锁，通过判断直接执行其他

defer_lock 见上

#include<iostream>
#include<list>
#include<thread>
#include<mutex>

using namespace std;
class son_thread {
public:
	void product() {
		for (int i = 0; i < 10000; i++) {
			
			unique_lock<mutex> myUniLock(my_mutex, defer_lock);
			myUniLock.lock();
			{	//my_mutex.lock();
				my_list.push_back(i);
				cout << "插入元素：" << i << endl;
				//my_mutex.unlock();
			}
			//my_mutex.unlock();
		}
	}
	void consume() {
		my_mutex.lock();
		if (my_list.empty()) {
			cout << "容器为空" << endl;
		}
		else {
			cout << " 进行消费" << my_list.front() << endl;
			my_list.pop_front();
		}
		my_mutex.unlock();
	}
	void consume_continue() {
		while (1) {
			this->consume();
		}
	}
private:
	std::mutex my_mutex;
	list<int>my_list;
};


int main() {
	son_thread s1;
	thread obj1(&son_thread::product, &s1);
	thread obj2(&son_thread::consume_continue,&s1);
	obj1.join();
	obj2.join();
	return 0;
}