Great question — this is one of those terms that feels redundant at first glance, but the extra "modify" carries critical semantic weight that sets it apart from a basic read-write pair.

First, let's reference the definition you pulled:

在计算机科学中，read-modify-write是一类原子操作……它会同时读取内存位置并向其中写入新值……

Here's the key breakdown of the difference:

• Atomicity and dependency are baked into the term
  A plain read-write usually describes two separate, independent operations: read a memory location, then later write to it (with no requirement that the write depends on the read). These two steps can be interrupted by other threads or processes. Read-modify-write, though, emphasizes that the three steps—read the value, modify that exact value (e.g., increment it, flip a bit), write the modified value back—are an indivisible atomic unit. The write isn't arbitrary; it directly relies on the value just read.

• Precision in semantics
  If we only used read-write, we couldn't distinguish between two very different scenarios:

  1. Reading a memory address, then writing a completely unrelated fixed value to it (this is read-write, but not read-modify-write).
  2. Reading a value, transforming it (like current_value + 1), then writing the result back (this is the read-modify-write pattern).
     The "modify" clarifies that the write is a direct product of the preceding read.

• Hardware-level context
  Most CPU instruction sets include dedicated atomic read-modify-write instructions (think x86's LOCK XADD or ARM's LDXR/STXR). These instructions are designed to prevent race conditions by ensuring no other thread can access the memory location between the read and write. A generic read-write term would fail to capture this hardware-specific atomic behavior, since a regular read followed by a write is never atomic on its own.

In short, "modify" isn't just a synonym for "write" here—it's a signal that the operation has a dependent, atomic nature that plain read-write pairs lack.

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