API
#syncMutex / WaitGroup / Once / RWMutex / Cond and atomic int.
struct Mutexpub struct Mutex {
pub tok chan int
}Mutex and WaitGroup are owning channel handles, not user-visible pointers and not atomic.Pointer. The token lives in the runtime channel object copies of Mutex share that object (like channel variables). Protected data still must move through channels — &mut must not cross xu (S6).
tok chan intstruct WaitGrouppub struct WaitGroup {
pub done chan int
pub pending int
}Public struct `WaitGroup`.
done chan intpending intmutexpub fn mutex() Mutexmutex; returns Mutex.
none
Mutex — a value of this type
(&mut Mutex) lockpub fn (m &mut Mutex) lock()Method on `&mut Mutex`: acquire the lock.
m &mut Mutex(&mut Mutex) unlockpub fn (m &mut Mutex) unlock()Method on `&mut Mutex`: release the lock.
m &mut Mutexwait_grouppub fn wait_group() WaitGroupWait group.
none
WaitGroup — a value of this type
(&mut WaitGroup) addpub fn (w &mut WaitGroup) add(delta int)Method on `&mut WaitGroup`: add.
w &mut WaitGroupdelta int(&mut WaitGroup) donepub fn (w &mut WaitGroup) done()Call `done` on `&mut WaitGroup`.
w &mut WaitGroup(&mut WaitGroup) waitpub fn (w &mut WaitGroup) wait(n int)Call `wait` on `&mut WaitGroup`.
w &mut WaitGroupn int(&mut WaitGroup) wait_pendingpub fn (w &mut WaitGroup) wait_pending()Method on `&mut WaitGroup`: wait pending.
w &mut WaitGroupload_intpub fn load_int(x &mut int) int===== sync/atomic ( sync/atomic, int-sized) ===== The runtime builtins are atomic_load / atomic_store / atomic_add atomic_cas — the `atomic_` prefix keeps them distinct from the wrapper names below (the same shadowing rule as the os package: a wrapper named `atomic_load` would shadow the builtin and self-recurse). Each builtin takes a mutable int location (`&mut int`; callers write `mut &x`). add returns the old value; cas returns a bool.
x &mut intint — a value of this type
store_intpub fn store_int(x &mut int, v int)Store int.
x &mut intv intadd_intpub fn add_int(x &mut int, d int) intAdd int.
x &mut intd intint — a value of this type
compare_and_swap_intpub fn compare_and_swap_int(x &mut int, old int, new int) boolCompare and swap int.
x &mut intold intnew intbool — true or false
struct Oncepub struct Once {
pub state int
pub mu Mutex
}===== Once ( sync.Once subset) ===== `do(f)` runs f at most once ( named fn values). `first_time` remains for call sites that prefer an explicit branch.
state intmu Mutexoncepub fn once() Onceonce; returns Once.
none
Once — a value of this type
(&mut Once) first_timepub fn (o &mut Once) first_time() boolMethod on `&mut Once`: first time.
o &mut Oncebool — true or false
(&mut Once) dopub fn (o &mut Once) do(f fn())Call `do` on `&mut Once`.
o &mut Oncef fn()struct RWMutexpub struct RWMutex {
pub mu Mutex
pub readers int
}===== RWMutex ( sync.RWMutex; reads do not run in parallel) ===== a single Mutex plus a reader count. Writers take the mutex; a reader takes it on entry (first-in) and releases it on exit (last-out), so reads serialize with each other and with writers — a documented divergence from parallel reads.
mu Mutexreaders intrw_mutexpub fn rw_mutex() RWMutexRw mutex.
none
RWMutex — a value of this type
(&mut RWMutex) read_lockpub fn (m &mut RWMutex) read_lock()Method on `&mut RWMutex`: acquire a shared read lock.
m &mut RWMutex(&mut RWMutex) read_unlockpub fn (m &mut RWMutex) read_unlock()Method on `&mut RWMutex`: release a read lock.
m &mut RWMutex(&mut RWMutex) write_lockpub fn (m &mut RWMutex) write_lock()Method on `&mut RWMutex`: acquire an exclusive write lock.
m &mut RWMutex(&mut RWMutex) write_unlockpub fn (m &mut RWMutex) write_unlock()Method on `&mut RWMutex`: release a write lock.
m &mut RWMutexstruct Condpub struct Cond {
pub q chan int
}===== Cond ( sync.Cond subset; ) ===== Locker is the Mutex passed to wait — no Locker interface. Callers must re-check the condition after wait returns (same contract as ). Notify is a shared channel so Cond values may be copied across `xu` (handles share the runtime object). No per-copy waiter counter.
q chan intcondpub fn cond() Condcond; returns Cond.
none
Cond — a value of this type
(&mut Cond) waitpub fn (c &mut Cond) wait(m &mut Mutex)Call `wait` on `&mut Cond`.
c &mut Condm &mut Mutex(&mut Cond) signalpub fn (c &mut Cond) signal()Call `signal` on `&mut Cond`.
c &mut Cond(&mut Cond) broadcastpub fn (c &mut Cond) broadcast()Call `broadcast` on `&mut Cond`.
c &mut Cond