Does `const` Guarantee Thread Safety in C 11?

Does const Imply Thread Safety in C 11?

The notion that const indicates thread safety in C 11 is partially true. According to the C Standard, expressions that solely modify or access the same memory location are considered conflicting. Data races arise when there are two conflicting actions in distinct threads, where at least one is not atomic and neither occurs before the other.

The Standard Library expects operations on const objects to be thread-safe. This means that the Standard Library won't introduce data races as long as operations on const objects of user-defined types:

• Comprise entirely of reads
• Internally synchronize writes

Breaching this expectation may result in data races for types that directly or indirectly interact with Standard Library components. Essentially, const implies thread safety from the Standard Library's perspective, but it remains a contract that the compiler doesn't enforce.

Const vs. Java's Synchronized

Const in C 11 is not equivalent to synchronized in Java. Consider a simplified rectangle class with set_size and area methods. area is thread-safe not because of const, but rather due to its read-only nature. However, set_size can cause data races if called concurrently with area.

To ensure thread safety for the rect class, const alone is insufficient. Writes must be internally synchronized, such as with a mutex, to prevent data races.

Implications for Thread Safety

Consider a rect class that caches its area to avoid costly calculations:

class rect {
    mutable int cached_area = 0;
    mutable bool cached_area_valid = true;
    // ...
};

The area method is no longer thread-safe since it performs writes. The inclusion of the rect instance in a standard container implies a contract with the Standard Library, which expects read behavior. To maintain this contract while performing writes, internal synchronization with a mutex is necessary:

class rect {
    mutable std::mutex cache_mutex;
    // ...
};

Conclusion

Const conveys thread safety in a limited sense, but it does not guarantee it. To achieve true thread safety, additional synchronization mechanisms may be required, especially for user-defined types that interact with the Standard Library.

The above is the detailed content of Does `const` Guarantee Thread Safety in C 11?. For more information, please follow other related articles on the PHP Chinese website!