某日二师兄参加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_mutex 和 std::mutex 有没有非阻塞的 api ?

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

面试官： std::lock_guard 和 std::unique_lock 用过吗?

二师兄：用过.

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

二师兄：相同点是两者都使用 RAII （资源获取即初始化）技术实现的锁，支持自动上锁，自动解锁.

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

1.灵活性： std::unqiue_lock 的灵活性要高于 std::lock_gurad ， std::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_gurad 和 std::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_gurad 和 std::unique_lock ，而 defer_lock_t/try_to_lock_t 只能用于 std::unique_lock .

关注我，带你21天“精通”C++！（狗头） 。

最后此篇关于C++面试八股文：如何避免死锁？的文章就讲到这里了,如果你想了解更多关于C++面试八股文：如何避免死锁？的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。