可变状态与竞态条件

When two threads touch the same mutable state, timing decides the result. That unpredictability is the root of subtle bugs.

A race condition happens when the outcome depends on which thread runs first. The same code can pass once and fail the next.

Two threads read a counter, both add one, and one write overwrites the other. You expected two increments but got just one.

The new memory manager removed freezing, but it did not remove races. Unsynchronized writes are still unsafe on every platform.

The simplest fix is confinement: let only one thread own the mutable data. Other threads send messages instead of writing directly.

Prefer immutable values you replace wholesale. Swapping one reference is atomic, so readers never see a half-updated object.

For shared writes, a Mutex lets one coroutine in at a time. It suspends others instead of blocking the thread.

For a single counter, an atomic wrapper updates safely without a lock. It compiles to native atomic operations on each target.

Driving updates through one StateFlow means a single source writes state. Many collectors read, but writes stay coordinated.

Races hide until load is high. Run shared logic from many coroutines in tests to flush out timing bugs before users do.

The best races are the ones you never create. Favor immutability and one owner, and most concurrency bugs simply vanish. ✅

A check on safe shared state.

You can now spot race conditions and fix them with confinement, immutable snapshots, a Mutex, or atomics. 🎉