您好,欢迎访问代理记账网站
移动应用 微信公众号 联系我们

咨询热线 -

电话 15988168888

联系客服
  • 价格透明
  • 信息保密
  • 进度掌控
  • 售后无忧

c++线程二

接上篇!

其实用mutex的lock()、unlock(), 当然更好用lock_guard(),这些基本能满足我们的应用需求,且容易理解。

一、unique_lock 相比lock_gaurd有一些更灵活的用法

主要体现在unique_lock的参数和成员函数上。如下一目了然,不再举例子。

unique_lock<mutex> uniqeLock(mu, std::adopt_lock);//同lock_guard, 指示不加锁,前提是mutex已经加锁
unique_lock<mutex> uniqeLock(mu, std::try_to_lock);//尝试加锁,用在获取不到锁时执行一些其他操作
unique_lock<mutex> uniqeLock(mu, std::defer_lock); //不加锁,且mutex尚未锁定,配合成员函数使用
uniqeLock.try_lock();  //同参数std::try_to_lock
uniqeLock.owns_lock(); //返回bool,表明是否拥有锁
uniqeLock.release();   //返回mutex,解除unique_lock与mutex的绑定,unique_lock为空

其次,我们常用的用法是unique_lock的控制粒度很细。

unique_lock在析构时会自动判断是否需要解锁:

unique_lock<mutex> ulock(mu);
//执行一些操作
ulock.unlock();  //我们可以随时unlock

ulock.lock();
//执行另外的操作

//不用unlock,会自动判断

二、以上的lock_guard、unique_lock用法都是基于mutex,

除此之外还有std::recursive_mutex和std::timed_mutex

1、recursive_mutex:递归互斥锁,相对于mutex的互斥锁

mutex myMutex;
void fun1()
{
	myMutex.lock();
	fun2();             //同样fun2中也需要锁,这种情况mutex显然不能胜任
	//线程1操作....
	myMutex.unlock();
}
void fun2()
{
	myMutex.lock();
	//线程2操作....
	myMutex.unlock();
}

int main()
{
	myMutex.lock();
	fun1();           //调用fun1,但mutex只能lock一次
	myMutex.unlock();

	return 0;
}

这种情况,只能用recursive_lock,能递归加锁,用于这种在同一线程嵌套调用加锁的情况。

即同一线程内lock或try_to_lock成功后开始占有锁,并可以多次lock,直到匹配到同样多的unlock后释放锁。早占有期间,其他线程lock会阻塞!

当然同mutex一样,最好是配合lock_guard和unique_lock使用。

2、std::timed_mutex 在一定时期内尝试获取锁,获取到锁就返回。

1、try_lock_for类似与unique_lock<mutx> uLock(mu, std::try_to_lock);

void fun2()
{
	while (true)
	{
		if (tMutex.try_lock_for(chrono::seconds(1)))
		{
			cout << "fun2 开始执行" << endl;
			tMutex.unlock();
		}
		else
		{
			cout << "fun2 没获取锁" << endl;
		}
	}
}

2、try_lock_until()

tMutex.try_lock_until(chrono::steady_clock::now()+10s)

3、当然同mutex,超时锁也有递归版本 :recursive_timed_mutex

二、条件变量condition_variable

互斥锁是用来防止竞争问题,条件变量是解决“线程同步”问题。一个线程处理完后,通知另外的线程处理。

1、wait()、  notify_one()、notify_all()

对wait()的使用,详见代码的注释,因为只要通知一个线程,所以用notify_one()通知。

class A
{
public:
	void inQueueMsg()
	{	
		for (int i = 0; i < 100000; i++)
		{
			unique_lock<mutex> uniqueLock(mu);
			cout << "线程id:" << this_thread::get_id() << " 插入数据" << endl;
			msgQueue.push(i);
			condv.notify_one();
		} 
	}
	void outQueueMsg()
	{
		for (int i = 0; i < 100000; i++)
		{
			unique_lock<mutex> uniqLock(mu);
			condv.wait(uniqLock, [this]() {  //wait有两个重载 分别为1个参数和两个参数,都必须用unique_lock
				if (msgQueue.empty())        //wait会阻塞线程,直到收到notify信号,此时的阻塞会释放拿到的锁,并进入睡眠
					return false;            //收到notify信号,会再次尝试获取锁,获取后若没有第二个参数则走下去,
				return true;                 //若有第二个参数,则判断,为真走下去,为假则再次释放锁,进入睡眠
			});
			//走到此处说明非空,不用判断
			int m = msgQueue.front();
			msgQueue.pop();
			cout << "outQueueMsg线程id:" << this_thread::get_id << " 读出数据:" << m << endl;
		}
	}
private:
	queue<int> msgQueue;
	mutex mu;
	condition_variable condv;
};

int main()
{
	A ac;
	thread t1(&A::outQueueMsg, &ac);
	thread t2(&A::inQueueMsg, &ac);
	t1.join();
	t2.join();
	
	return 0;
}

notify_one()只会唤醒一个wait的线程,此线程尝试去拿锁,拿不到则一直尝试拿;

nofity_all()唤醒所有wait的线程,所有线程都会去拿锁,但只有一个拿到,所以会“惊群”,其他拿不到锁的都会一直尝试拿锁!

另外,如果发送notify时,其他线程没在wait上阻塞,则此次notify不会产生任何作用(notify信号不会被储存,而是直接消失)。

三、原子操作

因为这种互斥的情况,c++标准增加原子操作,std::atomic<>类模板,但只能是针对内置普通变量,所以一般只用在计数上。

std::atomic<int> g_count = 0;
void func()
{
	for (int i = 0; i < 100000; i++)
		g_count++;   //不需互斥,因为本身是原子操作,执行时cpu不会调度
}
int main()
{
	thread t1(func);
	thread t2(func); //多个线程对g_count进行操作
	t1.join();
	t2.join();
	cout << "g_count=" << g_count << endl;
	
	return 0;
}


分享:

低价透明

统一报价,无隐形消费

金牌服务

一对一专属顾问7*24小时金牌服务

信息保密

个人信息安全有保障

售后无忧

服务出问题客服经理全程跟进