Atomic retry boundaries in Clojure STM to prevent duplicate writes

Answer

Use ref for shared state and dosync to wrap the complete atomic operation. Clojure's STM retries the entire dosync block from the beginning when a conflict occurs; you do not need a manual retry wrapper, and adding one around dosync can re-run side effects and create duplicates.

Confirmed facts and likely explanation

Confirmed: STM applies all ref changes in a transaction atomically, or retries the whole block. Confirmed: STM does not manage external systems such as databases, message queues, or file writes. Likely explanation: duplicate writes after a retry come from non-idempotent code inside dosync, or from an outer loop that re-invokes the transaction together with external I/O.

Steps for this case

1. Declare shared state with ref.
2. Place every read and write of that state inside a single dosync block.
3. Keep external side effects outside dosync, or make them idempotent and run them only after a successful commit.
4. Avoid wrapping dosync in a loop/recur retry unless the wrapper re-runs only transactional logic and never touches external systems.

(def balance (ref 100))

(defn transfer [from to amount]
  (dosync
    (when (>= @from amount)
      (alter from - amount)
      (alter to + amount))))

Verification: run the transfer under contention and check that the sum of all ref values stays constant after commits. If the sum changes, a partial write or side effect leaked outside the STM boundary.

Missing diagnostic detail: do you need to coordinate the STM commit with an external system, such as a database row or a message queue? If yes, STM alone cannot provide exactly-once semantics across that boundary; you will need an outbox or transactional log pattern.

Assumptions and uncertainty

This assumes standard Clojure STM behavior with ref, dosync, and alter. It does not cover third-party STM libraries or custom lock schemes. External idempotency is outside STM scope and must be verified separately.