构建稳固基石：C++线程安全Map的简单实现与应用("筑牢基础：C++线程安全Map简易实现及实用案例")

原创

ithorizon 6个月前 (10-20) 阅读数 19 #后端开发

构建稳固基石：C++线程平安Map的单纯实现与应用

一、引言

在多线程编程中，数据共享是节约程序高效能的重要手段。然而，多线程环境下对共享数据的访问需要谨慎处理，以避免出现数据竞争、死锁等问题。本文将介绍一种C++线程平安Map的单纯实现，并给出一些实用案例，帮助读者更好地懂得线程平安Map的用法。

二、线程平安Map的单纯实现

在C++中，STL库提供了多种数据结构，如vector、map等。然而，这些数据结构并非线程平安，所以在多线程环境下使用时需要额外的同步机制。下面我们将介绍一种基于互斥锁（mutex）的线程平安Map的单纯实现。

2.1 定义线程平安Map类


#include 
#include 
#include 
template 
class ThreadSafeMap {
private:
    std::map map_;
    mutable std::shared_mutex mutex_;
public:
    // 插入键值对
    void insert(const K& key, const V& value) {
        std::unique_lock lock(mutex_);
        map_[key] = value;
    }
    // 获取键对应的值
    bool get(const K& key, V& value) {
        std::shared_lock lock(mutex_);
        auto it = map_.find(key);
        if (it != map_.end()) {
            value = it->second;
            return true;
        }
        return false;
    }
    // 删除键值对
    bool erase(const K& key) {
        std::unique_lock lock(mutex_);
        return map_.erase(key) > 0;
    }
    // 判断键是否存在
    bool contains(const K& key) {
        std::shared_lock lock(mutex_);
        return map_.find(key) != map_.end();
    }
    // 获取Map大小
    size_t size() {
        std::shared_lock lock(mutex_);
        return map_.size();
    }
};

2.2 实现分析

在这个实现中，我们使用了一个std::map来存储键值对，同时使用了一个std::shared_mutex来保护这个map。std::shared_mutex是一种读写锁，允许多个线程同时读取数据，但写入数据时需要独占访问。具体来说：

对于读操作（如get、contains、size），我们使用std::shared_lock来锁定互斥锁，允许多个线程同时读取数据。

对于写操作（如insert、erase），我们使用std::unique_lock来锁定互斥锁，确保只有一个线程可以写入数据。

三、线程平安Map的应用案例

下面我们将通过一些实用案例来展示线程平安Map的使用方法。

3.1 线程平安的计数器

假设我们有一个计数器，需要多个线程对其进行增多操作。我们可以使用线程平安Map来实现这个功能：


#include 
#include 
#include 
void increment_counter(ThreadSafeMap& counter, int key) {
    counter.insert(key, counter.get(key, 0) + 1);
}
int main() {
    ThreadSafeMap counter;
    std::vector threads;
    // 启动10个线程，对键值为1的计数器进行增多操作
    for (int i = 0; i < 10; ++i) {
        threads.emplace_back(increment_counter, std::ref(counter), 1);
    }
    // 等待所有线程完成
    for (auto& t : threads) {
        t.join();
    }
    // 输出计数器的值
    int value = 0;
    if (counter.get(1, value)) {
        std::cout << "Counter value: " << value << std::endl;
    }
    return 0;
}

3.2 线程平安的缓存

在多线程环境下，我们可以使用线程平安Map来实现一个单纯的缓存。以下是一个示例：


#include 
#include 
#include 
#include 
// 缓存项
struct CacheItem {
    int value;
    std::chrono::steady_clock::time_point timestamp;
};
void access_cache(ThreadSafeMap& cache, int key) {
    CacheItem item;
    if (cache.get(key, item)) {
        std::cout << "Cache hit for key " << key << ": " << item.value << std::endl;
    } else {
        std::cout << "Cache miss for key " << key << std::endl;
        item.value = key * key;
        item.timestamp = std::chrono::steady_clock::now();
        cache.insert(key, item);
    }
}
int main() {
    ThreadSafeMap cache;
    std::vector threads;
    // 启动10个线程，访问缓存
    for (int i = 0; i < 10; ++i) {
        threads.emplace_back(access_cache, std::ref(cache), i);
    }
    // 等待所有线程完成
    for (auto& t : threads) {
        t.join();
    }
    return 0;
}