mutex：std::try_lock

引入

在多线程编程中，如何有效且安全地防止资源争用是保持程序性能和响应性的关键。C++11引入的 <mutex> 和 <shared_mutex> 头文件为此提供了丰富的工具，其中，std::try_lock 函数为开发者提供了一种尝试获取多个互斥量（mutex）的便捷方式，而非使用传统的等待方式。使用 try_lock，程序可以根据锁的状态决定是否继续执行，从而避免死锁或无谓的资源竞争，这在需要高响应性和并发处理的应用中尤为重要。

1. 特性与函数介绍

1.1 特性

• 非阻塞式尝试获取锁：std::try_lock 可以尝试获取一个或多个互斥量，如果锁不可用，它将不会阻塞线程，而是立即返回结果。
• 高效控制资源访问：相较于传统的锁定机制，try_lock 提供了更灵活的资源管理方式，减少了线程等待所占用的时间和系统资源。
• 多锁尝试：支持同时尝试获取多个互斥量，只需把它们作为参数传递，能够有效管理对多个资源的同步访问。

1.2 函数语法

std::try_lock 的基本语法如下：

#include <mutex>

template <class... MutexTypes>
int try_lock(MutexTypes&... mutexes); // 尝试获取多个互斥量

• 参数：

  • MutexTypes&... mutexes：要尝试获取的互斥量的引用，可传入多个互斥量。

• 返回值：成功获取所有锁时返回 0；若无法成功获取，则返回未成功获取锁的 mutex 的索引值。

2. 完整示例代码

以下示例代码展示了如何使用 std::try_lock 在多线程环境中有效地管理对多个资源的访问。

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

std::mutex mutexA;                 // 定义第一个互斥量
std::mutex mutexB;                 // 定义第二个互斥量
std::vector<int> sharedData;       // 共享数据容器

// 写入数据的函数
void writeData(int value) {
    // 尝试同时锁定两个互斥量
    if (std::try_lock(mutexA, mutexB) == 0) {
        // 成功获得锁
        sharedData.push_back(value); // 写入数据
        std::cout << "Thread " << std::this_thread::get_id() 
                  << " wrote value: " << value << std::endl;
        
        // 解锁
        mutexA.unlock();
        mutexB.unlock();
    } else {
        // 不能获得锁
        std::cout << "Thread " << std::this_thread::get_id() 
                  << " could not acquire locks." << std::endl;
    }
}

// 读取数据的函数
void readData() {
    std::unique_lock<std::mutex> lockA(mutexA); // 获取第一个锁
    std::unique_lock<std::mutex> lockB(mutexB); // 获取第二个锁

    // 读共享数据
    std::cout << "Thread " << std::this_thread::get_id() 
              << " reading values: ";
    for (const auto& val : sharedData) {
        std::cout << val << " "; // 输出共享数据
    }
    std::cout << std::endl;
    // locks will be released automatically when they go out of scope
}

int main() {
    const int numWriters = 3; // 定义写线程数量
    const int numReaders = 5;  // 定义读线程数量
    
    std::vector<std::thread> writers;
    std::vector<std::thread> readers;

    // 启动写线程
    for (int i = 1; i <= numWriters; ++i) {
        writers.emplace_back(writeData, i * 10); // 传入写入值
    }

    // 启动读线程
    for (int i = 0; i < numReaders; ++i) {
        readers.emplace_back(readData);
    }

    // 等待所有线程完成
    for (auto& writer : writers) {
        writer.join();
    }
    
    for (auto& reader : readers) {
        reader.join();
    }

    return 0;
}

3. 代码解析

1. 引入必要的头文件：

   • 代码示例包含了 <iostream>、<thread>、<mutex> 和 <vector>，用于支持多线程及互斥量管理。

2. 定义共享数据与互斥量：

   • 创建两个互斥量 std::mutex mutexA; 和 std::mutex mutexB; 用于多个线程间的同步保护，std::vector<int> sharedData; 用以存储共享数据。

3. 写入函数：

   • 在 writeData 中使用 std::try_lock(mutexA, mutexB) 尝试同时获得两个锁。如果成功，数据添加到共享数组里，并打印当前线程的信息；否则则输出无法获得锁的信息。

4. 读取函数：

   • 在 readData 中，通过 std::unique_lock 获取两个锁，使得可以安全地读取共享数据，并打印读取内容。

5. 主程序里的线程管理：

   • main 函数负责启动多个写和读线程，利用 join() 等待所有线程完成。

4. 适用场景分析

4.1 复杂多线程环境

在高度并发的应用中，可能有多线程同时尝试访问多个共享资源。使用 try_lock 可以有效避免互斥量的相互等待，提高执行效率。

4.2 高响应性的服务

在网络服务和实时计算中，快速响应用户请求是关键，使用 try_lock 避免无谓的线程阻塞，提供了优化反馈的方案。

4.3 资源竞争明显的应用

在竞争状态明显的应用中（如文件处理或多数据库系统），实现对多个锁的请求无阻塞处理，确保整体系统处于高效的运行状态。

5. 总结

std::try_lock 是现代 C++ 提供的重要功能之一，通过允许线程非阻塞地尝试获得一个或多个互斥量，极大地提升了并发程序的性能与灵活性。利用这一方法，开发者可以减少线程间的争用造成的资源浪费和系统延迟，从而构建出高效响应的多线程应用程序。掌握并应用 try_lock 不仅能提升个人的编码能力，更赋予开发团队构建高效且稳定软件的强大工具。通过合理的资源管理和优化，帮助开发者应付现代并发编程的挑战。