学习记录： C++ 多线程同步机制

std::lock_guard 与 CSingleLock 的比较与应用

在多线程编程中，如何安全、高效地访问共享资源是一个常见的挑战。多个线程可能会同时尝试读取或修改同一个资源，这就可能导致 资源竞争（race condition）和 数据竞争（data race）。为了解决这个问题，我们通常采用同步机制来确保资源在同一时刻只能被一个线程访问，从而避免这些问题。

常用的同步机制之一是 互斥量（mutex）。在 C++ 中，std::mutex 和 MFC 中的 CCriticalSection 都是用来保护共享资源的互斥量对象。为简化锁的管理，C++ 标准库和 MFC 都提供了用于自动化加锁和解锁的工具类：std::lock_guard 和 CSingleLock。

本文将详细讨论这两种工具的原理、使用方法以及它们在不同开发环境下的应用。

1. 互斥量（std::mutex）概述

互斥量（mutex）是用于控制多个线程对共享资源的访问的同步机制。只有成功获取锁的线程才能访问被保护的资源。互斥量的基本使用方式是：

• 锁定互斥量：当一个线程需要访问共享资源时，它首先需要获取互斥量的锁。
• 释放互斥量：当线程访问完资源后，需要释放锁，允许其他线程访问该资源。

std::mutex 提供了 lock() 和 unlock() 方法，开发者需要显式地调用这些方法来加锁和解锁。

然而，手动加锁和解锁可能会引入一些问题，比如忘记解锁导致死锁，或因为异常发生时没有正确释放锁而造成资源泄漏。

2. std::lock_guard：自动化锁管理

为了简化锁的管理，C++ 标准库提供了 std::lock_guard，它采用 RAII（资源获取即初始化） 原则，通过在对象生命周期内自动管理锁的加锁与解锁。

std::lock_guard 的工作原理：

• 构造时加锁：std::lock_guard 在构造时会自动调用 mutex.lock() 方法锁定传入的 mutex 对象。
• 析构时解锁：当 std::lock_guard 对象超出作用域时，它的析构函数会自动调用 mutex.unlock() 方法解锁，确保锁在作用域结束时被正确释放。

这种机制让开发者无需手动调用 lock() 和 unlock()，有效避免了因忘记解锁或异常中断导致的锁未释放问题。

#include <iostream>
#include <mutex>
#include <thread>

std::mutex g_mutex;  // 全局互斥量

void thread_function(int id) {
    // 在此作用域内加锁
    std::lock_guard<std::mutex> lock(g_mutex);  // 自动加锁
    std::cout << "Thread " << id << " is executing.\n";
    // lock 离开作用域后自动解锁
}

int main() {
    std::thread t1(thread_function, 1);
    std::thread t2(thread_function, 2);

    t1.join();
    t2.join();
    
    return 0;
}

3. MFC 中的 CSingleLock

在 MFC（Microsoft Foundation Classes）中，CSingleLock 类是另一个用于管理互斥量的工具。它的功能与 std::lock_guard 类似，同样采用 RAII 原则来简化锁的管理。

CSingleLock 是一个包装类，用于管理 CCriticalSection 对象的锁定和解锁。在 MFC 中，CCriticalSection 用于保护共享资源，CSingleLock 则负责简化对它的使用。

CSingleLock 的工作原理：

• 构造时加锁：CSingleLock 对象在构造时会尝试锁定传入的 CCriticalSection 对象。如果锁定成功，线程可以访问共享资源；如果锁定失败，线程会被阻塞，直到获得锁。
• 析构时解锁：当 CSingleLock 对象超出作用域时，它的析构函数会自动释放锁，确保资源的正确管理。

#include <afx.h>  // MFC 头文件

CCriticalSection m_criticalSection;

void thread_function() {
    // 创建 CSingleLock 对象，传入互斥量 m_criticalSection
    CSingleLock csl(&m_criticalSection);
    
    // 尝试锁定
    csl.Lock();
    
    // 访问共享资源
    std::cout << "Thread is executing. Critical section is locked.\n";
    
    // 锁会在 csl 离开作用域时自动释放
}

int main() {
    // 启动多个线程
    std::thread t1(thread_function);
    std::thread t2(thread_function);
    
    t1.join();
    t2.join();
    
    return 0;
}

最后总结：

无论是在 MFC 还是在标准 C++ 环境下，利用 RAII 原则来管理锁的加解锁，是现代多线程编程中的推荐做法。std::lock_guard 和 CSingleLock 都是出色的工具，它们使得线程同步变得更加安全、简洁，并减少了开发中的潜在错误。