int counter = 0;void *worker(void *arg){    for (int i = 0; i < 100000000; i++) counter++;    return NULL;}

int counter = 0;pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;void *worker(void *arg){    for (int i = 0; i < 100000000; i++) {        pthread_mutex_lock(&m);        counter++;        pthread_mutex_unlock(&m);    }    return NULL;}

#include<stdatomic.h>atomic_int counter = 0;void *worker(void *arg){    for (int i = 0; i < 100000000; i++) {        atomic_fetch_add_explicit(&counter, 1, memory_order_relaxed);    }    return NULL;}

load  counter -> r0    （Read）add   r0, 1            （Modify）store r0 -> counter    （Write）

#include<pthread.h>// 静态初始化（最方便）pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;// 或动态初始化pthread_mutex_t m;pthread_mutex_init(&m, NULL);// 加锁 / 解锁 / 销毁pthread_mutex_lock(&m);counter++;pthread_mutex_unlock(&m);pthread_mutex_destroy(&m);  // 必须在没人用了之后

intpthread_mutex_trylock(pthread_mutex_t *m);// 拿不到锁立即返回 EBUSY，不阻塞intpthread_mutex_timedlock(pthread_mutex_t *m, conststruct timespec *abstime);// 拿不到锁等到 abstime 时刻

struct mutex {    int state;   // 0 = 空闲；1 = 有人持有；2 = 有人持有 + 有等待者};void lock(mutex *m) {    /* ① fast path：无竞争 → 用户态 CAS，约 30-60 ns */    if (atomic_compare_exchange(&m->state, 0, 1)) return;    /* ② slow path：有人持有 → 进内核排队，约 1-10 μs */    while (atomic_exchange(&m->state, 2) != 0) {        syscall(SYS_futex, &m->state, FUTEX_WAIT, 2);    }}void unlock(mutex *m) {    int prev = atomic_exchange(&m->state, 0);    if (prev == 2) {        /* 有人在等 → syscall 唤醒 */        syscall(SYS_futex, &m->state, FUTEX_WAKE, 1);    }}

#include<stdatomic.h>atomic_int counter;atomic_init(&counter, 0);/* 原子加（RMW = Read-Modify-Write，单条指令完成） */atomic_fetch_add(&counter, 1);/* 简单读写 */int v = atomic_load(&counter);atomic_store(&counter, 0);/* CAS（compare-and-swap，原子条件写） */int expected = 10, desired = 20;atomic_compare_exchange_strong(&counter, &expected, desired);/* * 如果 *counter == expected：写入 desired，返回 true * 否则：把 *counter 实际值写回 expected，返回 false */

lock xadd %eax, (%rdi)

1: ldxr  w0, [x1]       ; load-exclusive，标记这块内存   add   w0, w0, #1   stxr  w2, w0, [x1]   ; store-exclusive，期间被改过会失败   cbnz  w2, 1b         ; 失败重试

atomic_fetch_add_explicit(&counter, 1, memory_order_relaxed);

/* 生产者线程 */data = 42;atomic_store_explicit(&ready, 1, memory_order_release);/* release 保证 data = 42 这个写在 store 之前完成 *//* 消费者线程 */while (atomic_load_explicit(&ready, memory_order_acquire) == 0)    /* spin */ ;/* acquire 保证读到 1 之后能看到 data = 42 */int x = data;   /* 一定是 42 */

atomic_int balance_a = 1000;atomic_int balance_b = 1000;void transfer(int amount) {    atomic_fetch_sub(&balance_a, amount);   /* ← 这里和下面之间有窗口期 */    /* 别的线程读 balance_a + balance_b 总和会少 amount */    atomic_fetch_add(&balance_b, amount);}

pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;int balance_a = 1000, balance_b = 1000;voidtransfer(int amount){    pthread_mutex_lock(&m);    balance_a -= amount;    balance_b += amount;    pthread_mutex_unlock(&m);}

atomic_int x;boolincrement_if_small(void) {    int cur = atomic_load(&x);    while (cur < 10) {        /* 期望当前是 cur，写入 cur+1；         * 如果中途被改过，cur 会被自动更新成新值，重试 */        if (atomic_compare_exchange_weak(&x, &cur, cur + 1))            return true;    }    return false;}

atomic_int x;/* ⛔ 这是三步，不是原子的 */int v = atomic_load(&x);v++;atomic_store(&x, v);/* ✅ 这才是原子的 */atomic_fetch_add(&x, 1);

/* ⛔ 用 relaxed 做生产者-消费者同步，可能读到 data 旧值 */data = 42;atomic_store_explicit(&ready, 1, memory_order_relaxed);/* ✅ 必须用 release */data = 42;atomic_store_explicit(&ready, 1, memory_order_release);

pthread_mutexattr_t attr;pthread_mutexattr_init(&attr);pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED);pthread_mutex_init(&m, &attr);   /* m 必须在共享内存里 */pthread_mutexattr_destroy(&attr);

struct foo {    pthread_mutex_t lock;    ...};struct foo *f = malloc(sizeof(*f));pthread_mutex_init(&f->lock, NULL);/* 用完了... */pthread_mutex_destroy(&f->lock);   /* ✅ 必须在 free 之前 */free(f);

atomic_bool b;b = true;            /* ⛔ 不是 atomic 操作 */atomic_store(&b, true);  /* ✅ */