const 成员的好处

一般地，对于不修改成员变量的函数申明为 const 类型，它隐含了是被传入的 this 指针为 const 类型。const 成员函数有两个好处：

不会修改成员变量（有特例，下面会介绍），比较安全。
可以被 const 和非 const 对象调用。非 const 成员变量无法被 const 对象调用。

由于 const 成员函数一般不会修改成员变量，因此 const 成员函数一般也是线程安全的。

const 成员函数的线程安全问题

凡是皆有例外。

考虑这样一个场景：用一个类来表示多项式，并求解其根。求根的过程不会修改多项式本身，因此我们可以设计如下：

class Polynomial {
public:
  using RootsType = std::vector<double>;
  …
  RootsType roots() const; // 此处省略其实现
  …
};

从功能角度来说，上面的设计没有问题。但是，求解根的代价一般都比较高，我们一般不希望重复计算多次。因此，我们可以将多项式的根缓存起来，只在必要的时候才计算，可以修改如下：

class Polynomial {
public:
  using RootsType = std::vector<double>;
  RootsType roots() const
  {
    if (!rootsAreValid) { // if cache not valid compute roots, store them in rootVals
      … 
      rootsAreValid = true;
    }
    return rootVals;
  }
private:
  mutable bool rootsAreValid{ false };
  mutable RootsType rootVals{};
};

从概念上说，求解根不会修改多项式本身。但是，缓存的行为又会修改多项式类的成员变量。经典的做法就是将成员变量申明为 mutable，成员函数申明为 const。

如果 const 成员函数不会被多个线程调用，那上述代码没有任何问题。

但是，当存在两以上的对象同时调用 const 成员变量，则会发生线程安全问题：这两个线程中的一个或两个都可能尝试去修改成员变量 rootsAreValid 和 rootVals。这意味着在没有同步的情况下，两个不同的线程读写同一段内存，这段代码会会有未定义的行为。

const 成员函数线程安全保证

很容易想到的解决办法是加 mutex：

class Polynomial {
public:
  using RootsType = std::vector<double>;
  RootsType roots() const
  {
    std::lock_guard<std::mutex> g(m); // lock mutex
    if (!rootsAreValid) { // if cache not valid, compute/store roots
      … 
      rootsAreValid = true;
    }
    return rootVals;
  } // unlock mutex
private:
  mutable std::mutex m;
  mutable bool rootsAreValid{ false };
  mutable RootsType rootVals{};
};

值得注意的是，由于 std::mutex 是 move-only 类型，所以包含了 std::mutex 变量的 Polynomial 对象也是 move-only 类型，失去了 copy 的能力。

在有些情况下，使用 std::mutex 的代价可能是比昂贵的。如果你只需要同步单一变量或者内存单元，使用 std::atomic 是相对比较廉价的。举个例子，你只需要统计一个成员函数被调用的次数：

class Point { // 2D point
public:
  …
  double distanceFromOrigin() const noexcept // see Item 14 for noexcept
  {
    ++callCount; // atomic increment
    return std::sqrt((x * x) + (y * y));
  }
private:
  mutable std::atomic<unsigned> callCount{ 0 };
  double x, y;
};