Are C Integer Reads and Writes Atomic in Multithreaded Environments?

Are C Reads and Writes of an Int Atomic? [duplicate]

Question:

In a multi-threaded application with one thread updating and another reading an integer, is it necessary to synchronize access to this multi-byte value? Can a partial write be interrupted before completion, allowing a read to capture an incomplete value?

Answer:

The atomicity of reads and writes of an integer in C depends on the architecture of the system.

Details:

• On IA32 systems: Correctly aligned addresses will have atomic reads and writes. Unaligned writes may be atomic depending on the cache.
• Caching: If the memory lies within a single L1 cache line, writes are atomic. If not, they may not be.
• Bus width: The width of the data bus affects atomicity. On some older systems, 16-bit writes to unaligned addresses were not atomic, while on systems with wider buses they were.
• Compiler optimizations: In C/C , it is important to mark the shared value as volatile to prevent the optimizer from assuming it is never updated in one thread.

Conclusion:

Whether synchronization is necessary depends on factors such as processor architecture, memory layout, and compiler optimizations. In general, it is recommended to synchronize access to shared multi-byte values, especially in critical sections where the order of reads and writes is relevant.

The above is the detailed content of Are C Integer Reads and Writes Atomic in Multithreaded Environments?. For more information, please follow other related articles on the PHP Chinese website!