1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

#include <thread>
#include <iostream>
using namespace std;

void worker(int id, const string& msg) {
    cout << "thread " << id << ": " << msg << endl;
}

int main() {
    thread t1(worker, 1, "hello");
    thread t2(worker, 2, "world");

    t1.join();  // 等待 t1 结束
    t2.join();  // 等待 t2 结束
    // 不 join 也不 detach 就析构 → std::terminate！
    return 0;
}

1
2
3
4
5
6
7
8

void worker(stop_token st) {
    while (!st.stop_requested()) {
        // 干活...
    }
}

jthread t(worker);
// 离开作用域时自动请求停止并 join

1
2
3
4
5
6
7
8

int counter = 0;
mutex mtx;

void increment() {
    lock_guard<mutex> lg(mtx);  // 构造 = lock，离开作用域 = unlock
    ++counter;
    // 到 } 自动析构解锁，异常安全
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

mutex mtx;

// 1. 延迟加锁
unique_lock<mutex> ul(mtx, defer_lock);  // 构造时不 lock
ul.lock();    // 稍后手动加锁
ul.unlock();  // 手动解锁
ul.lock();    // 再次加锁

// 2. 尝试加锁（不阻塞）
if (ul.try_lock()) { /* 拿到锁了 */ }

// 3. 转移所有权
auto ul2 = std::move(ul);  // ul 释放锁的所有权给 ul2

// 4. condition_variable 只能用 unique_lock
//    因为 cv.wait() 内部需要反复 unlock/lock，lock_guard 做不到
cv.wait(ul, []{ return ready; });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

lock_guard:
  ├── 内部只管两件事：构造时 mtx.lock()，析构时 mtx.unlock()
  ├── 没有任何状态标志、没有任何控制接口
  └── 设计意图：看到 lock_guard = 这个锁会被持满整个作用域，一眼明白

unique_lock:
  ├── 内部多了一个 bool owns_，追踪"当前是否持有锁"
  ├── unlock()  →  mtx.unlock(); owns_ = false;
  ├── lock()    →  mtx.lock();   owns_ = true;
  ├── 析构时    →  if (owns_) mtx.unlock();
  └── 设计意图：需要灵活操控锁的场景（cv、延迟加锁、转移所有权）

1
2

lock_guard<mutex> lg(mtx);    // 一眼看出：单锁，简单保护区
scoped_lock<mutex> sl(mtx);   // 功能完全相同，零额外开销

1
2

mutex mtx1, mtx2;
scoped_lock sl(mtx1, mtx2);  // 原子地锁定两个，不会死锁

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

shared_mutex rw;
int data = 0;

void reader() {
    shared_lock sl(rw);     // 共享锁，多个 reader 可以同时持有
    // 读取 data...
}

void writer() {
    unique_lock ul(rw);     // 排他锁，只有一个人能持有
    ++data;
}

1
2
3

1. 检查谓词 → true 就直接返回（不等待）
2. 谓词为 false → 原子地：释放 lock + 线程进入等待队列（阻塞）
3. 被唤醒后 → 重新获取 lock，再次检查谓词（应对虚假唤醒）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

#include <mutex>
#include <condition_variable>
#include <queue>
#include <thread>
#include <chrono>
#include <iostream>
using namespace std;
using namespace std::chrono;

struct NetMessage {
    int conn_id;
    string payload;
};

class LogicThread {
    mutex mtx_;
    condition_variable cv_;
    queue<NetMessage> msg_queue_;
    bool running_ = true;

public:
    // 网络线程调用：投递消息
    void post_message(NetMessage msg) {
        {
            lock_guard lg(mtx_);
            msg_queue_.push(std::move(msg));
        }
        cv_.notify_one();  // 唤醒逻辑线程
    }

    // 主线程调用：通知停机
    void shutdown() {
        {
            lock_guard lg(mtx_);
            running_ = false;
        }
        cv_.notify_all();
    }

    // 逻辑线程主循环
    void run() {
        while (true) {
            unique_lock ul(mtx_);

            // 等 100ms —— 要么有消息，要么超时
            bool has_msg = cv_.wait_for(ul, 100ms, [this] {
                return !msg_queue_.empty() || !running_;
            });

            if (!running_ && msg_queue_.empty()) {
                break;  // 停机且队列处理完毕
            }

            // 处理所有积压消息
            while (!msg_queue_.empty()) {
                NetMessage msg = std::move(msg_queue_.front());
                msg_queue_.pop();
                ul.unlock();       // 处理时不持锁
                process(msg);
                ul.lock();
            }

            if (!has_msg) {
                // 100ms 内没消息，做后台维护
                ul.unlock();
                check_heartbeats();
            }
        }
    }

private:
    void process(const NetMessage& msg) {
        cout << "conn " << msg.conn_id << ": " << msg.payload << endl;
    }

    void check_heartbeats() {
        cout << "[heartbeat check]" << endl;
    }
};

1
2
3
4
5

// 形式 1：不带谓词 —— 醒来后不会自动重新检查
cv.wait(lock);  // 被 notify 或虚假唤醒后返回，不管条件是否真正满足

// 形式 2：带谓词 —— 等价于 while(!pred) { wait(lock); }
cv.wait(lock, [] { return ready; });

1
2
3
4
5

消费者                              生产者
  持有锁，检查 ready == false
  准备释放锁+挂起（原子操作）
                                    lock, ready = true, notify_one (waiting queue 还是空的！)
  释放锁+挂起 ---> 永远睡下去了！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

3 个消费者都在 wait，等待队列中处理新消息：
  线程 A: [阻塞]  线程 B: [阻塞]  线程 C: [阻塞]

生产者放入 1 条消息，调用 notify_one():
  线程 A: [醒来处理消息]  线程 B: [阻塞]  线程 C: [阻塞]
  → 只醒了 1 个，因为只有 1 条消息，唤醒更多也是浪费

生产者调用 shutdown，调用 notify_all():
  线程 A: [醒来，看到 done=true，退出]
  线程 B: [醒来，看到 done=true，退出]
  线程 C: [醒来，看到 done=true，退出]
  → 全醒了，因为"停机"这个状态变更每人都需要知道

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// 错误！虚假唤醒时条件不满足，逻辑错误
cv.wait(ul);
// 直接使用被唤醒后的状态...

// 正确：用带谓词的 wait
cv.wait(ul, [] { return ready; });

// 或者等价的 while 循环写法（wait 内部就是这样做的）
while (!ready) {
    cv.wait(ul);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 生产者：先锁，改条件，解锁，再通知
{
    lock_guard lg(mtx);
    ready = true;  // 在锁的保护下修改条件
}
cv.notify_one();   // 通知放在解锁之后（性能更好）

// 消费者：wait 会在检查谓词为 true 时直接返回，不进入等待
unique_lock ul(mtx);
cv.wait(ul, [] { return ready; });  // 先检查谓词，true 就不等

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

unique_lock ul(mtx);
if (cv.wait_for(ul, 100ms, [] { return ready; })) {
    // 条件成立
} else {
    // 超时——可以做超时处理，比如打日志、检查心跳
}

auto deadline = chrono::steady_clock::now() + 5s;
if (cv.wait_until(ul, deadline, [] { return ready; })) {
    // ...
}

1
2
3
4
5
6
7
8
9

atomic<int> counter{0};

void increment() {
    counter.fetch_add(1, memory_order_relaxed);  // 原子自增
}

int get() {
    return counter.load(memory_order_acquire);    // 原子读取
}

1
2
3
4
5
6
7
8

once_flag init_flag;
ExpensiveResource* resource = nullptr;

void init() {
    call_once(init_flag, [] {
        resource = new ExpensiveResource();
    });
}

1
2

latch:  一次性倒计时 → 数到 0 就永久打开，不能重置
barrier: 可复用 → 每个阶段到齐后自动重置，进入下一轮

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

#include <latch>
#include <thread>
#include <vector>
using namespace std;

latch init_done(3);  // 3 个线程都初始化完才开门

struct GameModule {
    int id;
    void init() {
        // 每个模块独立的初始化工作（读配置、建立连接……）
        this_thread::sleep_for(chrono::milliseconds(id * 100));
        printf("module %d init done\n", id);
        init_done.arrive_and_wait();  // 报告完成，等其他人
    }
};

int main() {
    vector<thread> threads;
    for (int i = 0; i < 3; ++i) {
        threads.emplace_back([](int id) {
            GameModule{id}.init();
        }, i);
    }
    // 3 个线程都在 init_done 上挂着……
    // 最后一个到的时候门打开，大家一起往下走
    for (auto& t : threads) t.join();
    printf("all modules ready, server starts!\n");
}

1
2
3
4

module 0 init done
module 1 init done
module 2 init done
all modules ready, server starts!

1
2
3
4
5
6
7
8
9

latch done(1);

// 主线程
thread worker([&] {
    do_heavy_work();
    done.count_down();  // 通知：我完成了
});
done.wait();  // 主线程阻塞等 worker 干完
worker.join();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

#include <barrier>
#include <thread>
#include <vector>
using namespace std;

// 4 个工作线程 + 1 个主线程 = 5 个参与者
// 每个阶段结束时的回调：主线程负责聚合
auto on_phase_complete = []() noexcept {
    printf("--- phase complete, aggregating... ---\n");
    // 这里可以做：合并碰撞检测结果、更新 AI 状态、提交渲染命令等
};
barrier sync_point(5, on_phase_complete);

void worker(int id) {
    for (int frame = 0; frame < 3; ++frame) {
        printf("worker %d: frame %d - update physics\n", id, frame);
        sync_point.arrive_and_wait();  // 第 1 阶段：等所有人物理更新完

        printf("worker %d: frame %d - update AI\n", id, frame);
        sync_point.arrive_and_wait();  // 第 2 阶段：等所有人 AI 更新完
    }
}

int main() {
    vector<thread> workers;
    for (int i = 0; i < 4; ++i) {
        workers.emplace_back(worker, i);
    }

    for (int frame = 0; frame < 3; ++frame) {
        sync_point.arrive_and_wait();  // 主线程参与第 1 阶段
        sync_point.arrive_and_wait();  // 主线程参与第 2 阶段
    }

    for (auto& t : workers) t.join();
}

1
2
3
4
5
6

帧 0:
  worker 0-3: update physics → 到齐 → [回调：aggregating] → 全部释放
  worker 0-3: update AI      → 到齐 → [回调：aggregating] → 全部释放
帧 1:
  worker 0-3: update physics → 到齐 → [回调：aggregating] → 全部释放
  ...

1
2
3
4
5
6
7

thread_local int tls_counter = 0;  // 每个线程有独立的一份

void worker(int id) {
    ++tls_counter;
    printf("thread %d: counter = %d\n", id, tls_counter);
    // 每个线程输出都是 1 —— 互不干扰
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

线程 A                          线程 B
  TLS 区域                        TLS 区域
  ┌──────────────┐               ┌──────────────┐
  │ tls_counter  │ = 1           │ tls_counter  │ = 1
  │ 随机种子      │               │ 随机种子      │
  │ 日志缓冲区    │               │ 日志缓冲区    │
  └──────────────┘               └──────────────┘
       ↑                               ↑
       │                               │
  TLS 基址寄存器（如 Windows 的 gs 段寄存器）
  编译器生成的访问指令形如: mov eax, gs:[offset_of_tls_counter]

1
2
3
4
5
6

; 普通全局变量：直接寻址
mov  eax, [global_counter]          ; 所有线程访问同一地址

; thread_local 变量：段寄存器 + 偏移
mov  eax, gs:[0x38]                 ; gs 基址随线程不同而不同
                                     ; offset 0x38 = tls_counter 在 TLS 块内的位置

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// async：启动异步任务，返回 future
future<int> f = async(launch::async, [] { return 42; });
int result = f.get();  // 阻塞直到任务完成

// promise：手动设置结果
promise<int> p;
future<int> f2 = p.get_future();
thread t([&p] { p.set_value(100); });  // 另一个线程设置值
int val = f2.get();  // 100
t.join();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

#include <mutex>
#include <condition_variable>
#include <queue>
#include <thread>
#include <functional>
#include <vector>
using namespace std;

class ThreadPool {
public:
    explicit ThreadPool(size_t num_threads) : stop_(false) {
        for (size_t i = 0; i < num_threads; ++i) {
            workers_.emplace_back([this] {
                while (true) {
                    function<void()> task;
                    {
                        unique_lock ul(mtx_);
                        // 等任务到了，或者 stop
                        cv_.wait(ul, [this] {
                            return stop_ || !tasks_.empty();
                        });

                        if (stop_ && tasks_.empty()) {
                            return;   // 停机 + 队列空 → 线程退出
                        }

                        task = std::move(tasks_.front());
                        tasks_.pop();
                    }
                    task();  // 不持锁执行！
                }
            });
        }
    }

    ~ThreadPool() {
        {
            lock_guard lg(mtx_);
            stop_ = true;
        }
        cv_.notify_all();
        for (auto& t : workers_) {
            if (t.joinable()) t.join();
        }
    }

    // 提交一个任务到池子里
    void enqueue(function<void()> task) {
        {
            lock_guard lg(mtx_);
            tasks_.push(std::move(task));
        }
        cv_.notify_one();
    }

private:
    vector<thread>      workers_;
    queue<function<void()>> tasks_;
    mutex               mtx_;
    condition_variable  cv_;
    bool                stop_;
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

ThreadPool pool(4);  // 4 个工作线程

// 投递一批任务
for (int i = 0; i < 100; ++i) {
    pool.enqueue([i] {
        printf("task %d on thread %d\n", i, this_thread::get_id());
        this_thread::sleep_for(10ms);  // 模拟耗时操作
    });
}
// ThreadPool 析构时会等所有任务执行完再退出

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

class spinlock {
    atomic_flag flag = ATOMIC_FLAG_INIT;
public:
    void lock() {
        while (flag.test_and_set(memory_order_acquire)) {
            // 自旋等待；可加 _mm_pause() / yield() 降低功耗
        }
    }
    void unlock() { flag.clear(memory_order_release); }
};