C++获取当前线程索引实现线程专属缓存的高效方法咨询

我有一个类方法，它会根据index返回数据，但获取这些数据的开销极大。同时，该函数很可能会连续多次被传入同一个index值调用。为了提升效率，我希望缓存最近使用的index对应的结果。

单线程下的实现如下：

class DataAccess
{
  public:
    double GetValue(unsigned long index)
    {
      if (cached_index == index) return cached_value;

      /// 耗时极长的计算逻辑，最终得到result
      cached_value = result;
      cached_index = index;
      return result;
    }
  private:
    unsigned long cached_index;
    double cached_value;
};// class DataAccess

但该函数会被多线程调用，因此需要为每个线程单独存储缓存值。理想的实现思路是为每个线程分配一个索引，用数组存储对应缓存：

class DataAccessThreadSafe
{
  public:
    double GetValue(unsigned long index)
    {
      auto thread_idx = <获取当前线程索引>
      if (cached_index[thread_idx] == index)
      {  
        return cached_value[thread_idx];
      }
      /// 耗时极长的计算逻辑，最终得到result
      cached_value[thread_idx] = result;
      cached_index[thread_idx] = index;
      return result;
    }
  private:
    constexpr unsigned max_threads = 1024;
    std::array<unsigned long, max_threads> cached_index;
    std::array<double, max_threads> cached_value;
};// class DataAccessThreadSafe

但C++中std::this_thread::get_id()返回的是系统线程ID而非连续索引，所以我只能用std::map来关联线程ID和缓存：

class DataAccessThreadSafe
{
  public:
    double GetValue(unsigned long index)
    {
      auto& cached = cache[std::this_thread::get_id()];
      if (cached.index == index) return cached.value;

      /// 耗时极长的计算逻辑，最终得到result
      cached.value = result;
      cached.index = index;
      return result;
    }
  private:
    struct cache_type
    {
       cache_type() :
         index(std::numeric_limits<unsigned long>::max()), 
         value(0.0)
       {}

       cache_type(const cache_type&) = default;
       unsigned long index;
       double value;
    };
    std::map<std::thread::id, cache_type> cache;
};// class DataAccessThreadSafe

但std::map的查找效率不高，对此任务来说有些冗余。请问有没有更高效的方式匹配线程与其序号？或者有其他完全不同的解决方案？

1. 使用thread_local存储线程本地缓存 #

这是最简洁高效的方案，thread_local修饰的变量属于当前线程独有，不需要任何哈希或查找操作，直接访问即可。每个线程会维护自己的缓存副本，完全线程安全且性能最优。

实现代码：

#include <limits>
#include <thread>

class DataAccessThreadSafe
{
public:
    double GetValue(unsigned long index)
    {
        // 每个线程拥有独立的cache实例
        thread_local struct Cache {
            unsigned long index = std::numeric_limits<unsigned long>::max();
            double value = 0.0;
        } cache;

        if (cache.index == index) {
            return cache.value;
        }

        /// 耗时极长的计算逻辑，最终得到result
        cache.value = result;
        cache.index = index;
        return result;
    }
};

优点：零查找开销、实现简单、自动适配任意数量线程，无需手动管理线程索引或哈希表。
注意：thread_local变量的生命周期与线程绑定，线程销毁时自动释放。

2. 用std::unordered_map替代std::map #

如果不想用thread_local，可以将std::map替换为std::unordered_map——它基于哈希表实现，平均查找时间复杂度为O(1)，远优于std::map的O(logn)。

实现代码：

#include <unordered_map>
#include <thread>
#include <limits>
#include <mutex>

class DataAccessThreadSafe
{
public:
    double GetValue(unsigned long index)
    {
        std::lock_guard<std::mutex> lock(mtx); // 加锁保护哈希表的并发访问
        auto& cached = cache[std::this_thread::get_id()];
        
        if (cached.index == index) {
            return cached.value;
        }

        /// 耗时极长的计算逻辑，最终得到result
        cached.value = result;
        cached.index = index;
        return result;
    }

private:
    struct cache_type
    {
        cache_type() :
            index(std::numeric_limits<unsigned long>::max()), 
            value(0.0)
        {}

        unsigned long index;
        double value;
    };

    std::mutex mtx; // 必须加锁保证哈希表的线程安全
    std::unordered_map<std::thread::id, cache_type> cache;
};

注意：std::unordered_map本身不是线程安全的，必须加锁保护并发读写操作。如果计算逻辑的耗时远大于锁的开销，这种方案的性能损失可以忽略。

3. 自定义线程索引分配 #

如果坚持想用数组存储缓存，可以通过原子变量为每个新线程分配唯一的连续索引，从而实现O(1)的缓存访问。

实现代码：

#include <array>
#include <thread>
#include <atomic>
#include <limits>

class DataAccessThreadSafe
{
public:
    DataAccessThreadSafe() : next_thread_idx(0) {}

    double GetValue(unsigned long index)
    {
        // 首次调用时为当前线程分配唯一索引
        thread_local const unsigned int thread_idx = [this]() {
            return next_thread_idx++;
        }();

        // 确保索引不超过数组最大容量
        if (thread_idx >= max_threads) {
            // 处理超出容量的情况，比如直接计算不缓存，或扩容数组
            /// 耗时极长的计算逻辑，最终得到result
            return result;
        }

        if (cached_index[thread_idx] == index) {
            return cached_value[thread_idx];
        }

        /// 耗时极长的计算逻辑，最终得到result
        cached_value[thread_idx] = result;
        cached_index[thread_idx] = index;
        return result;
    }

private:
    constexpr static unsigned int max_threads = 1024;
    std::atomic<unsigned int> next_thread_idx;
    std::array<unsigned long, max_threads> cached_index;
    std::array<double, max_threads> cached_value;
};

优点：数组访问的开销极低，适合线程数量可控且不会超过预设最大值的场景。
缺点：需要预先设定最大线程数，若线程数量超过上限需额外处理；线程销毁后对应的数组空间无法回收（若需要复用索引，需更复杂的空闲索引管理逻辑）。

内容的提问来源于stack exchange，提问作者one_two_three