Const 在 C + + 11中是否意味着线程安全？

考虑下面这个表示矩形的过于简化的类:

class rect {
int width = 0, height = 0;


public:
/*...*/
void set_size( int new_width, int new_height ) {
width = new_width;
height = new_height;
}
int area() const {
return width * height;
}
};

成员函数成员函数 area是 thread-safe; 不是因为它的 const，而是因为它完全由读操作组成。没有涉及到写操作，而且至少有一个涉及到的写操作对于 data race的发生是必要的。这意味着您可以从任意多个线程调用 area，并且始终可以得到正确的结果。

注意，这并不意味着 rect就是 线程安全。事实上，很容易看出，如果对 area的调用与对给定 rect上的 set_size的调用同时发生，那么 area最终可能根据旧的宽度和新的高度(甚至根据混乱的值)计算结果。

But that is alright, rect isn't const so its not even expected to be 线程安全 after all. An object declared const rect, on the other hand, would be 线程安全 since no writes are possible (and if you are considering const_cast-ing something originally declared const then you get 未定义的行为 and that's it).

那是什么意思？

为了便于讨论，让我们假设乘法运算的代价非常高昂，最好在可能的情况下避免它们。我们可以计算面积，只有当它被请求，然后缓存它的情况下，它被请求再次在未来:

class rect {
int width = 0, height = 0;


mutable int cached_area = 0;
mutable bool cached_area_valid = true;


public:
/*...*/
void set_size( int new_width, int new_height ) {
cached_area_valid = ( width == new_width && height == new_height );
width = new_width;
height = new_height;
}
int area() const {
if( !cached_area_valid ) {
cached_area = width;
cached_area *= height;
cached_area_valid = true;
}
return cached_area;
}
};

[如果这个例子看起来太人为，你可以在心理上用一个 非常大的动态分配的整数来代替 int，这个 非常大的动态分配的整数本质上是非 线程安全的，而且对于它来说增殖是非常昂贵的。]

The 成员函数成员函数 area is no longer thread-safe, it is doing writes now and is not internally synchronized. Is it a problem? The call to area may happen as part of a 拷贝构造函数拷贝构造函数 of another object, such 构造函数 could have been called by some operation on a 标准集装箱, and at that point the 标准图书馆 expects this operation to behave as a 读 in regard to 数据竞赛. But we are doing writes!

一旦我们将 rect直接或间接地放到 标准集装箱中，我们就用 标准图书馆进入了 合约。要继续在 const函数中执行写操作，同时仍然遵守该契约，我们需要在内部同步这些写操作:

class rect {
int width = 0, height = 0;


mutable std::mutex cache_mutex;
mutable int cached_area = 0;
mutable bool cached_area_valid = true;


public:
/*...*/
void set_size( int new_width, int new_height ) {
if( new_width != width || new_height != height )
{
std::lock_guard< std::mutex > guard( cache_mutex );
        

cached_area_valid = false;
}
width = new_width;
height = new_height;
}
int area() const {
std::lock_guard< std::mutex > guard( cache_mutex );
        

if( !cached_area_valid ) {
cached_area = width;
cached_area *= height;
cached_area_valid = true;
}
return cached_area;
}
};

注意，我们使用了 area函数 线程安全，但是 rect仍然不是 线程安全。对 area的调用发生在对 set_size的调用仍然可能计算出错误的值的同时，因为对 width和 height的赋值不受互斥锁的保护。

If we really wanted a 线程安全 rect, we would use a synchronization primitive to protect the 非线程安全 rect.

他们没有 关键词了吗？

是的，他们从第一天起就没有 关键词了。

Source : 你不知道 ABC0和 mutable-< em > Herb Sutter