编辑“︁C++ 锁定策略”︁

{{DISPLAYTITLE:C++锁定策略}}  
[[Category:C++多线程]]  

== 概述 ==  
'''C++锁定策略'''是多线程编程中用于管理共享资源访问的核心机制，旨在防止'''数据竞争'''（Data Race）并确保线程安全。C++标准库通过<code>std::mutex</code>、<code>std::lock_guard</code>、<code>std::unique_lock</code>等工具提供多种锁定策略，开发者需根据场景选择适当的策略以平衡性能与安全性。  

== 为什么需要锁定策略？ ==  
多线程环境下，若多个线程同时修改共享数据，可能导致未定义行为。例如：  
<syntaxhighlight lang="cpp">  
#include <iostream>  
#include <thread>  

int counter = 0;  

void increment() {  
    for (int i = 0; i < 100000; ++i) {  
        ++counter; // 数据竞争！  
    }  
}  

int main() {  
    std::thread t1(increment);  
    std::thread t2(increment);  
    t1.join();  
    t2.join();  
    std::cout << "Counter: " << counter << std::endl; // 结果可能小于200000  
}  
</syntaxhighlight>  
'''输出示例（错误情况）'''：  
<pre>  
Counter: 132841  
</pre>  
通过锁定策略可解决此问题。  

== 基础锁定策略 ==  

=== 1. 互斥锁（std::mutex） ===  
最简单的锁定策略，通过<code>lock()</code>和<code>unlock()</code>显式控制临界区：  
<syntaxhighlight lang="cpp">  
#include <mutex>  

std::mutex mtx;  

void safe_increment() {  
    for (int i = 0; i < 100000; ++i) {  
        mtx.lock();  
        ++counter;  
        mtx.unlock();  
    }  
}  
</syntaxhighlight>  
'''注意'''：必须确保<code>unlock()</code>被调用，否则会导致死锁。  

=== 2. 自动锁管理（RAII） ===  
C++推荐使用'''RAII'''（Resource Acquisition Is Initialization）模式自动管理锁生命周期：  

==== std::lock_guard ====  
<syntaxhighlight lang="cpp">  
void safe_increment() {  
    for (int i = 0; i < 100000; ++i) {  
        std::lock_guard<std::mutex> lock(mtx); // 构造时加锁，析构时解锁  
        ++counter;  
    }  
}  
</syntaxhighlight>  

==== std::unique_lock ====  
更灵活的RAII锁，支持延迟锁定和所有权转移：  
<syntaxhighlight lang="cpp">  
void transfer_lock(std::unique_lock<std::mutex> lock) {  
    // 锁所有权转移  
}  

void flexible_increment() {  
    std::unique_lock<std::mutex> lock(mtx, std::defer_lock); // 延迟锁定  
    lock.lock();  
    ++counter;  
    transfer_lock(std::move(lock)); // 转移所有权  
}  
</syntaxhighlight>  

== 高级锁定策略 ==  

=== 1. 递归锁（std::recursive_mutex） ===  
允许同一线程多次获取锁，解决嵌套调用问题：  
<syntaxhighlight lang="cpp">  
std::recursive_mutex rec_mtx;  

void nested_function() {  
    std::lock_guard<std::recursive_mutex> lock(rec_mtx);  
    // 可重入代码  
}  
</syntaxhighlight>  

=== 2. 读写锁（std::shared_mutex） ===  
C++17引入，区分读写操作以提高并发性：  
<syntaxhighlight lang="cpp">  
#include <shared_mutex>  

std::shared_mutex sh_mtx;  

void read_data() {  
    std::shared_lock<std::shared_mutex> lock(sh_mtx); // 共享锁（多读）  
    // 读取数据  
}  

void write_data() {  
    std::unique_lock<std::shared_mutex> lock(sh_mtx); // 独占锁（单写）  
    // 修改数据  
}  
</syntaxhighlight>  

=== 3. 死锁避免策略 ===  
使用<code>std::lock</code>或<code>std::scoped_lock</code>（C++17）同时锁定多个互斥量：  
<syntaxhighlight lang="cpp">  
std::mutex mtx1, mtx2;  

void safe_transaction() {  
    std::scoped_lock lock(mtx1, mtx2); // 自动避免死锁  
    // 操作多个受保护资源  
}  
</syntaxhighlight>  

== 性能考量 ==  
锁定策略的选择直接影响性能：  
* '''粗粒度锁'''：简单但并发性低。  
* '''细粒度锁'''：复杂但并发性高。  

<mermaid>  
graph LR  
    A[锁定策略] --> B[互斥锁]  
    A --> C[读写锁]  
    A --> D[无锁编程]  
    B --> E[std::mutex]  
    B --> F[std::recursive_mutex]  
    C --> G[std::shared_mutex]  
</mermaid>  

== 实际案例 ==  
'''场景'''：线程安全的日志系统  
<syntaxhighlight lang="cpp">  
#include <fstream>  
#include <queue>  
#include <shared_mutex>  

class ThreadSafeLogger {  
    std::ofstream log_file;  
    std::shared_mutex file_mtx;  
public:  
    void log(const std::string& message) {  
        std::unique_lock lock(file_mtx);  
        log_file << message << std::endl;  
    }  
};  
</syntaxhighlight>  

== 数学基础 ==  
锁的公平性可通过排队理论分析。设锁争用概率为<math>p</math>，则平均等待时间：  
<math> 
T_{wait} = \frac{p}{1 - p} \times T_{critical} 
</math>  

== 总结 ==  
* 优先使用RAII锁（如<code>std::lock_guard</code>）。  
* 高并发读场景选择<code>std::shared_mutex</code>。  
* 避免嵌套锁或使用递归锁。  
* 多锁操作时使用<code>std::scoped_lock</code>。

[[Category:编程语言]]
[[Category:C++]]
[[Category:C++ 多线程]]