索引

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