MULTI enters transaction mode, the valid SET queues, the wrong-arity GET is detected while building the queue, and EXEC aborts or returns the queued-error outcome.

Every check waits for EXEC, where the wrong-arity GET fails mid-batch and the commands after it are skipped — the queue stays deliberately opaque until the whole batch is visible, so checks can span commands.

The wrong-arity GET is silently dropped from the queue, and EXEC runs the lone SET successfully.

MULTI validates the upcoming commands when it starts, so the error surfaces before the GET is even sent.

EXEC returns one error reply and rolls back the effect of the first command before any client sees it.

EXEC stops at the failure, returning two replies and leaving the third command unexecuted in the queue, which the client can resubmit after fixing the failing command in isolation.

EXEC returns an array with one reply per queued command, including a wrong-type error in the middle position rather than rolling back earlier replies.

EXEC returns nil, exactly as it does when a watched key was modified before execution.

WATCH takes a shared lock that other readers can hold too, upgrading to exclusive only at EXEC.

WATCH locks the key against writes while still permitting reads, like a reader-writer lock.

WATCH blocks other clients' writes only between MULTI and EXEC, a window kept deliberately short to minimize contention on heavily written keys.

WATCH marks the transaction dirty if another client changes the key; it does not lock or block that other client.

Only the MULTI flag, since the queued commands live in the database where EXEC can find them.

The client owns transaction mode, the queued commands, watched keys, dirty state, and cleanup state until EXEC or DISCARD.

The queue plus a snapshot of every watched key's value, so EXEC can compare bytes to detect conflicts.

Nothing at all, because the client library batches commands locally and ships them with the final EXEC in one network burst, the same trick pipelining uses.

All three are atomic, and they differ only in how many round trips each one saves.

MULTI/EXEC supports branching on intermediate replies, because each queued command returns its value at queue time.

Pipelining saves round trips without atomicity, MULTI/EXEC queues commands without branching on intermediate results, and scripts run atomically with server-side branching.

Scripts save the most round trips but cannot write keys, so atomic writes still require MULTI/EXEC.