C++面试八股文:如何避免死锁?

某日二师兄参加XXX科技公司的C++工程师开发岗位第31面:

面试官:什么是锁?有什么作用?

二师兄:在C++中,锁(Lock)是一种同步工具,用于保护共享资源,防止多个线程同时访问,从而避免数据竞争和不一致。

面试官:有哪些锁?

二师兄:从种类上分,可以分为普通锁、读写锁、递归锁等种类。

二师兄:从实现上分,可以分为互斥锁、自旋锁、信号量、条件变量等。

面试官:互斥锁如何使用?

二师兄:在C++11之前,C++便准层面并没有定义锁,锁的应用要依赖于平台。Linux下使用pthread库中的mutex

#include <pthread.h>
pthread_mutex_t mutex_ = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_lock(&mutex_);
//被保护的区域
pthread_mutex_unlock(&mutex_);

二师兄:C++11引入了std::mutex,统一了各个平台上互斥锁的使用:

#include <mutex>
std::mutex mutex_;
mutex_.lock();
//被保护的区域
mutex_.unlock();

面试官:pthread_mutexstd::mutex有没有非阻塞的api

二师兄:有的,分别是pthread_mutex_trylock()try_lock(),当获取不到锁时这两者并不阻塞当前线程,而是立即返回。需要注意的是,当pthread_mutex_trylock()获取到锁时返回0,而std::mutex::try_lock()方法获取不到锁时返回false

面试官:std::lock_guardstd::unique_lock用过吗?

二师兄:用过。

面试官:两者有什么相同点和不同点?

二师兄:相同点是两者都使用RAII(资源获取即初始化)技术实现的锁,支持自动上锁,自动解锁。

二师兄:不同点主要包括三个方面:

1.灵活性:std::unqiue_lock的灵活性要高于std::lock_guradstd::unique_lock可以在任何时间解锁和锁定,而std::lock_guard在构造时锁定,在析构时解锁,不能手动控制。

2.所有权:std::unique_lock支持所有权转移,而std::lock_gurad不支持。

3.性能:由于std::unique_lock的灵活性更高,它的性能可能会稍微低一些。

面试官:能实现一个lock_gurad吗?

二师兄:我尝试一下:

class lock_guard
{
    explicit lock_guard(std::mutex& m):mutex_(m)
    {
        mutex_.lock();
    }
    ~lock_guard()
    {
        mutex_unlock();
    }
private:
    std::mutex& mutex_;
};

面试官:为什么会发生死锁?

二师兄:当进程A持有锁1请求锁2,进程B持有锁2请求锁1时,两者都不会释放自己的锁,两者都需要对方的锁,就会造成死锁。当然现实中可能比这要复杂,但原理是相同的。

面试官:如何避免死锁?

二师兄:主要从以下几个方面入手:

1.避免循环等待,如果需要在业务中获取不同的锁,保证所有业务按照相同的顺序获取锁。

2.使用超时锁,当锁超时时,自动释放锁。

3.使用try_lock,当锁被占用时,返回false并继续执行。

4.锁的粒度尽量要小,只保护竟态数据而不是整个流程。

面试官:知道adopt_lock_t/defer_lock_t/try_to_lock_t这三种类型的用法吗?

二师兄:额。。不知道。。

面试官:好的,回去等通知吧。

让我们来看看最后一个问题:

知道adopt_lock_t/defer_lock_t/try_to_lock_t这三种类型的用法吗?

adopt_lock_t/defer_lock_t/try_to_lock_t都是空类,主要表示std::lock_guradstd::unqiue_lock的默认构造中的操作:

adopt_lock_t:默认互斥量已被当前线程锁定,不使用lock()方法对互斥量加锁:

std::mutex mtx_;
mtx_.lock();	//lock
{
    std::lock_guard<std::mutex> lock_(mtx_,std::adopt_lock);	//这里默认当前线程已经对mtx_加过锁
    ...
}//unlock

defer_lock_t:虽然我拥有了std::mutex的引用,但是在构造函数中并不调用lock()方法对互斥量加锁:

std::mutex mtx_;
{
    std::unique_lock<std::mutex> ulock_(mtx_,std::defer_lock);	//这里并没有加锁
    ulock_.lock();
    if(ulock_.owns_lock())
    {
		//locked
    }else
    {
		//unlocked
    }
}//if locked,unlock

try_to_lock_t:在构造函数执行是并不是使用lock()方法加锁,而是使用try_lock()方法加锁:

std::mutex mtx_;
{
    std::unique_lock<std::mutex> ulock_(mtx_,std::try_to_lock);	//这里mtx_如果没有被锁定,则加锁成功,否则加锁失败
    if(ulock_.owns_lock())
    {
		//locked
    }else
    {
		//unlocked
    }
}//if locked,unlock

adopt_lock_t可以用于std::lock_guradstd::unique_lock,而defer_lock_t/try_to_lock_t只能用于std::unique_lock

关注我,带你21天“精通”C++!(狗头)

热门相关:总裁别再玩了   道君   重生野性时代   重生野性时代   民国之文豪崛起