C++11--锁分析

1 介绍

互斥量(mutex)类型，用于线程同步，防止数据竞争(data race)。

2 锁嵌套问题

示例

class Motor
{
public:
	void api_1{} {
		mutex.lock();
		// do something
		api_2{}
		mutex.unlock();
	}
	void api_2{} {
		mutex.lock();
		// do something
		mutex.unlock();
	}
	
private:
	mutex mutex;
}

解决方案一：使用分层锁设计，避免嵌套

class Motor {
public:
    void api_1() {
        std::lock_guard<std::mutex> lock(mutex);
        // do something that doesn't call api_2
    }
    
    void api_2() {
        std::lock_guard<std::mutex> lock(mutex);
        // do something
    }
    
private:
    std::mutex mutex;
};

解决方案二：重构设计，避免方法间互相调用受锁保护的操作

class Motor {
public:
    void api_1() {
        std::lock_guard<std::mutex> lock(mutex);
        // do something
        api_2_locked();  // 专门为已锁定情况设计的方法
    }
    
    void api_2() {
        std::lock_guard<std::mutex> lock(mutex);
        api_2_locked();
    }
    
private:
    void api_2_locked() {
        // 必须在持有锁的情况下调用
        // do something
    }
    
    std::mutex mutex;
};

解决方案三：使用递归锁（不推荐，除非确实需要）

注意：递归锁通常表明设计有问题，应尽量避免。

class Motor {
public:
    void api_1() {
        std::unique_lock<std::recursive_mutex> lock(mutex);
        // do something
        api_2(); // 现在可以安全调用
    }
    
    void api_2() {
        std::unique_lock<std::recursive_mutex> lock(mutex);
        // do something
    }
    
private:
    std::recursive_mutex mutex;
};