Skip to content

Latest commit

 

History

History
922 lines (872 loc) · 26.4 KB

attachment.md

File metadata and controls

922 lines (872 loc) · 26.4 KB
Raw

索引

A

  • AArch64（参见 ARM64）
  • ABA 问题，#
  • 终止进程，#
  • AcqRel，#
    • （参见 release 和 acquire 内存排序）
  • acquire 内存排序（参见 release 和 acquire 内存排序）
  • add 指令（ARM），#
  • add 指令（x86），#
  • 基于地址的等待（Windows），#
    • （参见 futex）
  • 凭空出现的值，#
  • alignment，#
  • 分配（参见 ID 分配）
  • AMD 处理器，#
  • and 指令（x86），#
  • Arc，#
    • 构建我们自己的 Arc，#
    • 循环结构，#
    • get_mut，#
    • 内存排序，#，#，#，#
    • 命名克隆，#
    • 用于 Channel 的情况，#
    • weak 指针，#
      • 性能开销，#
  • arguments，consuming，#
  • ARM64（处理器架构），#
    • aarch64-unknown-linux-musl target，#
    • other-multi-copy atomic，#
    • weakly ordered，#
  • ARM64 指令
    • add，#
    • ARMv8.1 atomic instructions，#，#
    • b.ne (branch if not equal)，#
    • cbnz (compare and branch on nonzero)，#
    • clrex (clear exclusive)，#
    • cmp (compare)，#
    • dmb (data memory barrier)，#
    • ldar (load-acquire register)，#
    • ldaxr (load-acquire exclusive register)，#
    • ldr (load register)，#
    • ldxr (load exclusive register)，#
    • load-linked and store-conditional instructions，#
    • mov (move)，#
    • overview，#
    • ret (return)，#
    • stlr (store-release register)，#
    • stlxr (store-release exclusive register)，#
    • str (store register)，#
    • stxr (store exclusive register)，#
  • ARMv8 (see ARM64)
  • ARMv8.1 atomic instructions，#，#
    • overview，#
  • array::from_fn，#
  • assembler，#
  • assembly，#
    • inspecting compiler output，#
  • atomic，#，#
    • compare-and-exchange operations，#
      • weak，#，#，#，#，#，#，#，#，#，#，#，#
    • fetch-and-modify operations，#
      • wrapping behavior (add and sub)，#，#，#，#
    • load and store operations，#
      • example，stop flag，#，#，#，#，#
    • memory ordering (see memory ordering)
    • reference counting (see Arc)
  • atomic barriers (see fences)
  • atomic fences (see fences)
  • atomic types，#，#
    • compare_exchange，#
    • compare_exchange_weak，#
    • fetch_add，#
      • wrapping behavior，#
      • (see also overflows)
    • fetch_and，#
    • fetch_max，#
    • fetch_min，#
    • fetch_nand，#
    • fetch_or，#
    • fetch_store (see swap)
    • fetch_sub，#
      • wrapping behavior，#
      • (see also overflows)
    • fetch_update，#
    • fetch_xor，#
    • get_mut，#
    • load，#
    • store，#
    • swap，#
  • atomic-wait crate，#
  • AtomicBool，#
    • (see also atomic types)
    • locking using，#，#
  • AtomicI8 (see atomic types)
  • AtomicI16 (see atomic types)
  • AtomicI32 (see atomic types)
  • AtomicI64 (see atomic types)
  • AtomicIsize (see atomic types)
  • AtomicPtr，#
    • (see also atomic types)
    • compare-and-exchange，#
    • lazy initialization，#
  • AtomicU8 (see atomic types)
  • AtomicU16 (see atomic types)
  • AtomicU32 (see atomic types)
  • AtomicU64 (see atomic types)
  • AtomicUsize (see atomic types)
  • auto traits，#

B

  • b.ne (branch if not equal) instruction (ARM)，#
  • barriers (see fences)
  • basics，#
  • benchmarking，#，#
    • black_box，avoiding optimizations with，#，#
  • binary semaphore，#
  • black_box，#，#
  • blocking，#
    • channel，#
    • condition variables，#
    • futex wait operation，#
    • (see also futex)
    • mutexes，#
    • Once and OnceLock，#，#
    • semaphores，#
    • spin loop，#
    • thread parking (see thread parking)
  • boolean (atomic) (see AtomicBool)
  • borrowing，#
    • bending the rules，#
    • error，#
    • exclusive，#
    • from multiple threads (Sync)，#
    • immutable，#
    • (see also shared)
    • local variables in a thread，#
    • mutable，#
    • (see also exclusive)
    • shared，#
    • splitting，#
    • undefined behavior，#
  • Box
    • from_raw，#，#
    • into_raw，#
    • leak，#，#
    • unmovable type，wrapping in，#
  • btc (bit test and complement) instruction (x86)，#
  • btr (bit test and reset) instruction (x86)，#
  • bts (bit test and set) instruction (x86)，#
  • building our own
    • Arc，#
    • channels，#
    • condition variables，#
    • mutexes，#
    • reader-writer locks，#
    • spin locks，#
  • busy-looping，#
    • (see also spinning)

C

  • C standard library，#
    • (see also libc)
  • cache coherence，#
    • protocol，#
      • write-through，#，#，#，#
  • cache lines，#
    • performance experiment，#
  • cache miss，#
  • caching (processors)，#
    • (see also cache coherence)
    • compare-and-exchange operations，effect of，#
    • per core，#
    • performance experiment，#
  • cargo-show-asm，#
  • cas (compare and swap) instruction (ARM)，#
  • casa (compare and swap，acquire) instruction (ARM)，#
  • casal (compare and swap，acquire and release) instruction (ARM)，#
  • casl (compare and swap，release) instruction (ARM)，#
  • cbnz (compare and branch on nonzero) instruction (ARM)，#
  • Cell，#
    • unsafe (see UnsafeCell)
  • channels
    • blocking，#
    • borrowing，#
    • building our own，#
    • dropping，#
    • one-shot，#
    • safe interface，#
    • Sender and Receiver types，#，#
    • storing in Arc，#
      • avoiding，#
    • unsafe interface，#
  • Clone trait，#，#，#，#，#
  • closures
    • captured values
      • moving，#，#
    • spawning scoped threads using，#
    • spawning threads using，#
  • clrex (clear exclusive) instruction (ARM)，#
  • cmp (compare) instruction (ARM)，#
  • cmpxchg (compare and exchange) instruction (x86)，#
  • #[cold]，#
  • compare-and-exchange operations (atomic)，#
    • on ARM64，#
    • caching，effect on，#
    • compiler optimization，#
    • example，ID allocation，#
    • example，lazy initialization，#，#
    • memory ordering，#
    • using for channel state，#
    • using for mutex state，#
    • using for reader-writer lock state，#
    • using on AtomicPtr，#
    • using to lock reference counter，#
    • weak，#
      • on ARM64，#
    • on x86-64，#
  • Compiler Explorer，#
  • compiler fence，#，#
  • compiler optimization
    • black_box，avoiding with，#，#
    • #[cold]，#
    • of compare-and-exchange loops，#
    • enabling，#，#
    • #[inline] #
    • reordering，#
  • complex instruction set computer (CISC)，#
  • concurrency，basics，#
  • condition variables，#
    • building our own，#
    • example，#
    • memory ordering，#
    • pthread_cond_t，#
    • thundering herd problem，#
    • timeout，#
    • using to build a channel，#
    • Windows，#
  • Condvar，#
    • (see also condition variables)
  • consume memory ordering，#
  • consuming arguments by value，#
  • contention (mutexes)，#，#
    • benchmarking，#
  • Copy trait，#，#
    • atomic types，not implementing，#
    • moving，#
  • critical section (Windows)，#
  • current thread，#，#，#
  • cyclic structures (Arc)，#

D

  • data races，#
    • avoiding using atomics，#，#
  • Deref trait，#，#，#
  • DerefMut trait，#，#，#，#
  • disassembler，#，#
  • dmb (data memory barrier) instruction (ARM)，#
  • drop function，#，#，#
  • Drop trait，#，#，#，#，#，#，#，#，#，#，#，#
  • dword，#

E

  • --emit=asm (rustc)，#
  • exclusive references，#

F

  • fair locks，#
  • false sharing，#
  • fences，#，#，#
    • on ARM64，#
    • compiler fence，#，#
    • instructions，#
    • process-wide memory barriers，#
    • on x86-64，#
  • fetch-and-modify operations (atomic)，#
    • on ARM64，#
    • example，ID allocation，#
    • example，progress reporting，#
    • example，statistics，#
    • wrapping behavior (add and sub)，#
      • (see also overflows)
    • on x86-64，#
  • fetch_store operation (atomic) (see swap operation)
  • fetch_update (atomic)，#
  • FlushProcessWriteBuffers (Windows)，#
  • forgetting (see leaking)
  • FreeBSD，umtx_op syscall，#
    • (see also futex)
  • from_fn (array)，#
  • futex，#
    • cross-platform futex-like functionality，#
    • example，#
    • memory safety，#
    • on other platforms，#
    • operations (Linux)，#
      • FUTEX_WAIT，#，#，#，#，#，#，#，#，#，#，#
    • requeuing，#，#
    • spurious wake-ups，#
    • timeout，#，#
    • wait operation，#
    • wake operation，#

G

  • globally consistent order，#
    • (see also sequentially consistent memory ordering)
  • Godbolt，#
  • good luck，#
  • guards
    • dropping，#
    • join guard，#
    • mutex guard，#，#
    • read guard，#，#
    • spin lock guard，#
    • write guard，#，#

H

  • hand，things getting out of，#
  • happens-before relationships，#
    • in Arc，#，#
    • between threads，#
    • locking and unlocking，#，#
    • spawning and joining threads，#
    • through a release-acquire pair，#，#
      • chaining，#
    • within the same thread，#
  • hint::black_box，#，#
  • hint::spin_loop，#

I

  • ID allocation
    • using compare_exchange_weak，#
    • using fetch_add，#
    • using fetch_update，#
  • ideas and inspiration，#
  • if let statement
    • lifetime of temporaries，#
  • ignorance，blissful，#
  • immutable references，#
    • (see also shared references)
  • indivisible，#
  • #[inline]，#
  • inspiration，#
  • Instant，#
  • instruction reordering (see reordering)
  • instructions，#
    • (see also ARM64 instructions; x86-64 instructions)
    • compare-and-exchange operations，#，#
    • fences，#
    • load and store operations，#
    • load-linked/store-conditional (LL/SC) instructions，#
    • memory ordering，#
    • overview，#
    • read-modify-write operations，#
  • Intel processors，#
  • interior mutability，#，#，#
  • invalidation queues，#

J

  • jne (jump if not equal) instruction (x86)，#
  • join method，#
  • JoinGuard，#
  • JoinHandle，#
  • joining threads，#
    • happens-before relationship，#

K

  • kernel，#，#
    • interfacing with，#
    • kernel-managed objects (Windows)，#

L

  • L1/L2/L3/L4 cache，#
  • label (assembly)，#
  • lazy initialization
    • using compare_exchange，#
    • using compare_exchange and allocation，#
    • using load and store，#
  • ldadd (load and add) instruction (ARM)，#
  • ldadda (load and add，acquire) instruction (ARM)，#
  • ldaddal (load and add，acquire and release) instruction (ARM)，#
  • ldaddl (load and add，release) instruction (ARM)，#
  • ldar (load-acquire register) instruction (ARM)，#
  • ldaxr (load-acquire exclusive register) instruction (ARM)，#
  • ldr (load register) instruction (ARM)，#
  • ldxr (load exclusive register) instruction (ARM)，#
  • leaking，#，#
    • by mistake，#
    • a MutexGuard，#
  • “Leakpocalypse”，#
  • libc，#
    • pthreads functionality in，#
  • libpthread，#
    • (see also pthreads)
  • lifetime
    • elision，#，#
    • in a struct，#
    • of mutex guard，#
    • specifying using plain English，#
    • static，#
  • linked list，#
    • Linux
      • futex syscall，#
      • (see also futex)
    • arguments，#
    • futex_waitv syscall，#
    • interfacing with the kernel，#
    • libc，role of，#
    • membarrier syscall，#
    • process-wide memory barrier，#
    • RCU，#
  • load and store operations (atomic)，#
    • on ARM64 and x86-64，#
    • compared to non-atomic operations，#，#
    • example，lazy initialization，#
    • example，progress reporting，#
    • example，stop flag，#
  • load-linked/store-conditional (LL/SC) loop，#
    • on ARM64，#
    • compiler optimization，#
  • lock poisoning，#
  • lock prefix (x86)，#
  • lock_api crate，#
  • luck，good，#

M

  • machine code，#
  • machine instructions (see instructions)
  • macOS
    • futex-like functionality on，#
    • interfacing with the kernel，#，#
    • os_unfair_lock，#
  • main thread，#
  • ManuallyDrop，#
  • MaybeUninit，#，#，#
  • mem::forget，#
  • membarrier syscall，#
  • memory barriers (see fences)
  • memory fences (see fences)
  • memory model，#
  • memory ordering，#，#
    • on ARM64，#
    • compiler fence，#，#
    • consume，#
    • experiment，using relaxed instead of release and acquire，#
    • fences，#，#，#
    • happens-before relationship，#，#
    • Miri，detecting problems with，#
    • misconceptons about，#
    • out-of-thin-air values，#
    • at processor level，#
    • reference counting，#，#，#，#，#
    • relaxed，#，#
    • release and acquire，#
      • (see also release and acquire memory ordering)
      • locking and unlocking，#
    • sequentially consistent，#
      • (see also sequentially consistent memory ordering)
    • specifying using plain English，#
    • total modification order，#，#，#，#
    • on x86-64，#
  • MESI cache coherence protocol，#
  • MESIF cache coherence protocol，#
  • mfence (memory fence) instruction (x86)，#
  • microinstructions，#
  • Miri，#
  • MOESI cache coherence protocol，#
  • mov (move) instruction (ARM)，#
  • mov (move) instruction (x86)，#
  • movable，not
    • critical section (Windows)，#
    • Pin，#
    • pthread types，#
    • wrapping in Box，#
  • move closure，#
  • multi-copy atomicity，#
  • mutability，interior (see interior mutability)
  • mutable references，#
    • (see also exclusive references)
  • Mutex，#，#
    • (see also mutexes)
  • mutexes，#
    • building our own，#
    • as container，#
    • contention，#，#
    • example，#
    • fair，#
    • happens-before relationship，#
    • into_inner，#
    • lifetime of mutex guard，#
    • memory ordering，#
    • Mutex type in Rust，#
    • os_unfair_lock (macOS)，#
    • in other languages，#
    • poisoning，#
    • pthread
      • wrapping in Rust，#
    • pthread_mutex_t，#
    • recursive，#
    • robust，#
    • Send requirement，#
    • spin locks，#
      • (see also spin locks)
    • spinning，#，#
    • using to build a channel，#
  • MutexGuard，#
    • dropping，#
    • lifetime of，#
  • mutual exclusion (see mutexes)

N

  • name of a thread，#
  • NetBSD，futex support，#
    • (see also futex)
  • NonNull，#

O

  • -O flag (rustc)，#，#
  • Once and OnceLock，#，#
  • one-shot channels，#
  • OpenBSD，limited futex support，#
    • (see also futex)
  • operating systems，#
    • (see also Linux; macOS; Windows)
    • libraries shipped with，#
    • synchronization primitives，#
  • optimization (see compiler optimization)
  • or instruction (x86)，#，#
  • Ordering，#，#
    • AcqRel，#
      • (see also release and acquire memory ordering)
    • Acquire，#
      • (see also release and acquire memory ordering)
    • Consume，#
    • Relaxed，#，#
    • Release，#
      • (see also release and acquire memory ordering)
    • SeqCst，#
      • (see also sequentially consistent memory ordering)
  • os_unfair_lock (macOS)，#
  • other-multi-copy atomicity，#
  • out of order execution (see reordering)
  • out-of-thin-air values，#
  • output locking，#
  • overflows (atomic)，#
    • (see also wrapping behavior)
    • aborting on，#
    • notification counter，#
    • panicking on，#
    • preventing (compare-and-exchange)，#
    • reference counter，#
    • usize，big enough，#
  • overview of atomic instructions，#
  • ownership
    • moving，#，#
    • sharing，#
    • transferring to another thread (Send)，#

P

  • panicking
    • poisoned mutexes，#
    • RefCell，borrowing，#
    • thread name in panic messages，#
    • using a Condvar with multiple mutexes，#
    • when joining a thread，#，#
    • when spawning a thread，#
  • parking (see thread parking)
  • parking lot-based locks，#
  • parking_lot crate，#
  • PhantomData，#，#
  • Pin，#
  • pipelining，#
  • pointers
    • atomic (see AtomicPtr)
    • neither Send nor Sync，#
    • NonNull，#
  • poisoning，lock，#
  • POSIX，#
    • pthreads，#
  • println，use of output locking，#
  • priority inheritance，#
  • priority inversion，#
  • privacy (modules)，#
  • process-wide memory barriers，#
  • processes，#
  • processor architecture，#
    • (see also ARM64; x86-64)
    • strongly ordered，#
    • weakly ordered，#
  • processor caching (see caching)
  • processor instructions (see instructions)
  • processor registers，#
    • return value，#
  • pthreads，#
    • pthread_cond_t，#，#
    • pthread_mutex_t，#
    • dropping while locked，#
    • pthread_rwlock_t，#
    • wrapping in Rust，#

Q

  • queue-based locks，#

R

  • racing，#
  • Rc，#
  • RCU (read，copy，update)，#，#
  • reader-writer locks，#
    • avoiding accidental spinning，#
    • building our own，#
    • pthread_rwlock_t，#
    • Send requirement，#
    • SRW locks (Windows)，#
    • Sync requirement，#
    • writer starvation，#，#
  • recursive locking，#，#
  • reduced instruction set computer (RISC)，#
  • RefCell，#
    • RwLock compared to，#
  • reference counting，#
    • (see also Arc)
  • references
    • exclusive，#
    • immutable，#
      • (see also shared)
    • mutable，#
      • (see also exclusive)
    • shared，#
  • registers，#
    • return value，#
  • relaxed memory ordering，#，#，#
    • counter-intuitive results，#
    • misconceptions about，#，#
    • out-of-thin-air values，#
    • reference counting，#
    • total modification order，#，#，#，#
  • release and acquire memory ordering，#
    • acquire fence，#，#，#，#，#
    • on ARM64，#
    • example，lazy initialization，#
    • experiment，using relaxed instead，#
    • happens-before relationship，#，#
      • chaining，#
    • locking and unlocking，#，#
    • reference counting，#，#，#，#
    • release fence，#
    • on x86-64，#
  • --release flag (cargo)，#，#
  • reordering (instructions)，#，#
    • memory ordering，#
  • #[repr(align)]，#
  • requeuing waiting threads，#，#
  • ret (return) instruction (ARM)，#
  • ret (return) instruction (x86)，#
  • robust mutexes，#
  • rustup，#
  • RwLock，#，#
    • (see also reader-writer locks)
  • RwLockReadGuard，#
  • RwLockWriteGuard，#

S

  • safe interface，#，#，#
  • safety requirements of unsafe functions，#
  • scheduler，#
  • scoped threads，#
  • semaphores，#
  • Send trait，#，#，#
    • error，#
    • implementing for Arc，#
    • requirement by Mutex and RwLock，#
  • SeqCst (see sequentially consistent memory ordering)
  • sequence locks，#
  • sequentially consistent memory ordering，#
    • on ARM64，#
    • fence，#
    • misconceptions about，#，#
    • on x86-64，#
  • shadowing，#
  • shared ownership，#
    • leaking，#
    • reference counting，#
    • statics，#
  • shared references，#
    • mutating atomics through，#
  • slim reader-writer locks (Windows)，#，#
  • spawning threads，#
    • failing to，#
    • happens-before relationship，#
    • scoped，#
  • spin locks
    • building our own，#
    • cache lines，effect of，#
    • compare-and-exchange，(not) using，#
    • experiment，using wrong memory ordering，#
    • guard，#
    • memory ordering，#
  • spin loop hint，#，#
  • spinning，#，#，#
    • avoiding accidental (reader-writer lock)，#
  • splitting (borrowing)，#
  • spurious wake-ups，#，#，#
  • SRW locks (Windows)，#，#
  • stack size，#
  • starvation，#，#
  • static lifetime，#
  • statics，#
  • stlr (store-release register) instruction (ARM)，#
  • stlxr (store-release exclusive register) instruction (ARM)，#
  • stop flag，#
  • store buffers，#
  • store operations (atomic) (see load and store operations)
  • store-conditional (see load-linked/store-conditional)
  • str (store register) instruction (ARM)，#
  • stress，reducing，#
  • strongly ordered architecture，#
  • stxr (store exclusive register) instruction (ARM)，#
  • sub (subtract) instruction (x86)，#
  • swap operation (atomic)，#
    • locking using，#
  • Sync trait，#，#
    • implementing for Arc，#
    • implementing for channel，#
    • implementing for mutex，#
    • implementing for reader-writer lock，#
    • implementing for spin lock，#
    • requirement by RwLock，#
  • SYS_futex (Linux)，#
    • (see also futex)
    • arguments，#
  • syscalls，#
    • avoiding，#，#

T

  • --target (rustc)，#
  • teaching，#
  • thin air，out of，#
  • thread builder，#
  • thread name，#
  • Thread object，#
    • id，#
    • unpark，#，#
  • thread parking，#，#，#，#
    • spurious wake-ups，#
  • timeout，#
    • example，#
  • thread safety，#，#
    • keeping objects on one thread，#
  • ThreadId，#
  • threads，#
    • joining，#
    • panicking，#，#
    • returning a value，#
    • scoped，#
    • spawning，#
  • thundering herd problem，#
  • time travel，#
  • timeout
    • condition variables，#
    • futex，#，#
  • thread parking，#
    • example，#
  • total modification order，#，#，#，#

U

  • uncontended (mutexes)，#，#
    • benchmarking，#
  • undefined behavior，#
    • borrowing，#
    • data races，#
    • Miri，detecting with，#
    • time travel，#
  • uninitialized memory，#
  • Unix systems
    • interfacing with the kernel，#
    • libc，role of，#
  • unmovable
    • critical section (Windows)，#
    • Pin，#
    • pthread types，#
    • wrapping in Box，#
  • unpark (Thread)，#
  • unparking (see thread parking)
  • unsafe code，#
  • unsafe functions，#
  • unsafe trait implementation，#
  • UnsafeCell，#，#，#
    • get_mut，#
  • unsound，#

V

  • VecDeque，#

W

  • waiting (see blocking)
  • WaitOnAddress (Windows)，#
  • WakeByAddressAll (Windows)，#
  • WakeByAddressSingle (Windows)，#
  • Weak (see Arc; weak pointers)
  • weakly ordered architecture，#
    • experiment，using relaxed instead of release and acquire，#
  • Windows，#
    • condition variables，#
    • critical section，#
    • FlushProcessWriteBuffers，#
    • interfacing with the kernel，#
    • kernel-managed objects，#
    • Native API，#
    • process-wide memory barrier，#
    • SRW locks，#，#
  • WaitOnAddress，#
  • WakeByAddressAll，#
  • WakeByAddressSingle，#
  • Win32 API，#
  • windows crate，#
  • windows-sys crate，#
  • wrapping behavior (fetch_add and fetch_sub)，#
    • (see also overflows (atomic))
  • wrapping unmovable object in Box，#
  • write-through cache coherence protocol，#
  • writer starvation，#，#

X

  • x86-64 (processor architecture)，#
    • other-multi-copy atomic，#
    • strongly ordered，#
    • x86_64-unknown-linux-musl target，#
  • x86-64 instructions
    • add，#
    • and，#
    • btc (bit test and complement)，#
    • btr (bit test and reset)，#
    • bts (bit test and set)，#
    • cmpxchg (compare and exchange)，#
    • jne (jump if not equal)，#
    • lock prefix，#
    • mfence (memory fence)，#
    • mov (move)，#
    • or，#，#
    • overview，#
    • ret (return)，#
    • sub (subtract)，#
    • xadd (exchange and add)，#
    • xchg (exchange)，#，#
    • xor，#
  • xadd (exchange and add) instruction (x86)，#
  • xchg (exchange) instruction (x86)，#，#
  • xor instruction (x86)，#

译注

英文 中译 可能出现章节
allocation 内存分配 1、3、5、6、8、10
atomic 原子 all
benchmark 基准测试 4、9
borrow 借用 1、4、5
building block 基石 1、2、8、10
cache coherence 缓存一致性 7
compare and exchange 比较并交换 3、4、6、9
condition variable 条件变量 1、2、5、8、9
drop 丢弃 1、3、4、5、6、9
fetch and modify 获取并修改 1、3
fence 屏障 3、6、7、8
formalize 形式化的 3
guard 守卫 4、9
happens-before happens-before 3、4、5、6、7、9
Invalidation queue 失效队列 7
leak （内存）泄漏 1、3、5、8、10
load operation load 操作 2、3、5、6、7、8、9
lock（v） 锁定 all
memory ordering 内存排序 2、3、4、5、6、7、9
mutex 互斥锁 1、2、3、4、8、9
mutation 可变性 1、2、4、6、8
notify 通知 1、4、5、8、9
notify_all notify all 9
notify_one notify one 9
park/block 阻塞 all
pipeline 流水线 7
reader-writer lock 读写锁 1、3、4、8、9
reader reader 1、4、8、9、10
receiver 接收者 5
reference 引用 all
spinLock 自旋锁 3、4、8、9
sender 发送者 5
spurious 虚假的 1、2、5、8、9
static 静态值 1
stop the world 停止其他活动 7
store buffer 存储缓冲区 7
store operation store 操作 2、3、5、6、7、8、9
swap operation swap 操作 2、3、5、6、7、8、9
syscall 系统调用 8、9
unlock（v） 解锁 all
unpark 释放 all
use cases 用例 all
wait(er) 等待（者） all
writer writer 1、4、8、9、10