1
#include <thread>
2

3
void worker(int id, const std::string& name) {
4
    std::cout << "Thread " << id << ": " << name << "\n";
5
}
6

7
// 创建线程
8
std::thread t1(worker, 1, "Alice");
9
std::thread t2(worker, 2, "Bob");
10

11
// 必须 join 或 detach，否则析构时 std::terminate
12
t1.join();    // 阻塞等待 t1 完成
13
t2.detach();  // 放到后台运行，t2 生命周期与主线程无关
14

15
// ⚠️ 参数传递的陷阱：
16
int x = 42;
17
// std::thread t3(func, std::ref(x));  // 传引用必须用 std::ref
18
// 否则 x 会被拷贝到线程内部
19

20
// 移动语义的线程
21
std::thread t4([](int val) {
22
    std::cout << "Lambda: " << val << "\n";
23
}, 100);
24

25
auto t5 = std::move(t4);  // 线程所有权转移
26
// t4 不再关联线程
27
t5.join();

1
#include <mutex>
2

3
std::mutex mtx;
4
int shared_counter = 0;
5

6
// ❌ 不加锁：数据竞争
7
void bad_increment() {
8
    for (int i = 0; i < 100000; ++i) {
9
        shared_counter++;  // 非原子操作：读-改-写
10
    }
11
}
12

13
// ✅ 用 mutex 保护
14
void safe_increment() {
15
    for (int i = 0; i < 100000; ++i) {
16
        std::lock_guard<std::mutex> lock(mtx);   // 构造时加锁
17
        shared_counter++;
18
    }   // 析构时自动解锁
19
}

1
#include <condition_variable>
2

3
std::mutex mtx;
4
std::condition_variable cv;
5
std::queue<int> task_queue;
6
bool done = false;
7

8
// 生产者
9
void producer() {
10
    for (int i = 0; i < 10; ++i) {
11
        {
12
            std::lock_guard lock(mtx);
13
            task_queue.push(i);
14
        }
15
        cv.notify_one();  // 通知一个等待的消费者
16
    }
17
    {
18
        std::lock_guard lock(mtx);
19
        done = true;
20
    }
21
    cv.notify_all();  // 通知所有消费者结束
22
}
23

24
// 消费者
25
void consumer(int id) {
26
    while (true) {
27
        std::unique_lock lock(mtx);
28
        cv.wait(lock, [&]() {
29
            return !task_queue.empty() || done;
30
        });
31
        // ↑ wait 做的事情：
32
        // 1. 如果条件为 false → 解锁 mutex 并休眠
33
        // 2. 被 notify 唤醒后 → 重新加锁 → 再次检查条件
34
        // 3. 条件为 true → 继续执行
35

36
        if (task_queue.empty() && done) break;
37

38
        int task = task_queue.front();
39
        task_queue.pop();
40
        lock.unlock();  // 处理前释放锁
41

42
        std::cout << "Consumer " << id << " processing: " << task << "\n";
43
    }
44
}

1
#include <future>
2

3
// std::async：把任务提交到线程池（或新线程）
4
auto future = std::async(std::launch::async, []() {
5
    // 后台执行的耗时操作
6
    std::this_thread::sleep_for(std::chrono::seconds(2));
7
    return 42;
8
});
9

10
// 主线程继续干别的...
11
std::cout << "Doing other work...\n";
12

13
// 需要结果时阻塞等待
14
int result = future.get();  // 阻塞直到任务完成，返回 42
15

16
// std::promise + std::future：手动设置结果
17
std::promise<int> prom;
18
auto fut = prom.get_future();
19

20
std::thread t([&prom]() {
21
    int result = heavy_computation();
22
    prom.set_value(result);  // 设置结果
23
});
24

25
int val = fut.get();  // 阻塞等待 set_value
26
t.join();

1
// === 陷阱 1：数据竞争 ===
2
int counter = 0;
3
// 两个线程同时执行 counter++
4
// counter++ 不是原子操作！它是 read-modify-write 三步
5
// 解决：std::atomic<int> 或 mutex
6

7
// === 陷阱 2：AB-BA 死锁 ===
8
std::mutex m1, m2;
9
// 线程 1: lock(m1) → lock(m2)
10
// 线程 2: lock(m2) → lock(m1)
11
// → 互相等待 → 死锁！
12
// 解决：std::scoped_lock(m1, m2) 或固定加锁顺序
13

14
// === 陷阱 3：条件变量用 if 判断 ===
15
// ❌
16
cv.wait(lock);
17
if (queue.empty()) return;  // 虚假唤醒时 queue 可能仍为空！
18

19
// ✅
20
cv.wait(lock, [&]{ return !queue.empty(); });  // lambda 自动循环检查
21

22
// === 陷阱 4：detach 的悬垂引用 ===
23
void bad_detach() {
24
    int local = 42;
25
    std::thread t([&local]() {
26
        std::this_thread::sleep_for(std::chrono::seconds(1));
27
        std::cout << local;  // 💥 local 已经销毁！
28
    });
29
    t.detach();  // 线程在后台运行
30
}   // local 在这里销毁，但线程还在用它
31

32
// ✅ 值捕获或确保生命周期
33
void good_detach() {
34
    int local = 42;
35
    std::thread t([local]() {  // 值捕获
36
        std::cout << local;    // ✅ 安全
37
    });
38
    t.detach();
39
}
40

41
// === 陷阱 5：volatile ≠ 线程安全 ===
42
volatile int flag = 0;
43
// volatile 只防止编译器优化掉读取（用于硬件寄存器）
44
// 它不保证原子性，也不保证内存可见性
45
// ❌ 不能用于线程同步
46
// ✅ 用 std::atomic<int> flag

1
// 双缓冲同步：逻辑线程写入帧数据，渲染线程读取上一帧数据
2
struct FrameData {
3
    std::vector<DrawCommand> draw_commands;
4
    glm::mat4 view_matrix;
5
    glm::mat4 proj_matrix;
6
    float time;
7
};
8

9
class DoubleBuffer {
10
    FrameData _buffers[2];
11
    std::atomic<int> _write_index{0};
12
    std::atomic<bool> _new_frame{false};
13

14
public:
15
    // 逻辑线程：写入当前帧数据
16
    FrameData& getWriteBuffer() {
17
        return _buffers[_write_index.load()];
18
    }
19

20
    void swapBuffers() {
21
        _write_index.store(1 - _write_index.load());
22
        _new_frame.store(true, std::memory_order_release);
23
    }
24

25
    // 渲染线程：读取上一帧数据
26
    const FrameData& getReadBuffer() const {
27
        return _buffers[1 - _write_index.load(std::memory_order_acquire)];
28
    }
29

30
    bool hasNewFrame() const {
31
        return _new_frame.exchange(false);
32
    }
33
};
34

35
// 主循环：
36
DoubleBuffer frame_buffer;
37

38
// 逻辑线程
39
std::jthread logic_thread([&](std::stop_token st) {
40
    while (!st.stop_requested()) {
41
        auto& buf = frame_buffer.getWriteBuffer();
42
        // 更新游戏逻辑 → 填充 draw_commands
43
        updateGameLogic(buf);
44
        frame_buffer.swapBuffers();
45
    }
46
});
47

48
// 渲染线程（主线程）
49
while (running) {
50
    if (frame_buffer.hasNewFrame()) {
51
        const auto& buf = frame_buffer.getReadBuffer();
52
        renderFrame(buf);
53
    }
54
}

1
class ThreadPool {
2
    std::vector<std::thread> _workers;
3
    std::queue<std::function<void()>> _tasks;
4
    std::mutex _mutex;
5
    std::condition_variable _cv;
6
    bool _stop = false;
7

8
public:
9
    ThreadPool(size_t num_threads) {
10
        for (size_t i = 0; i < num_threads; ++i) {
11
            _workers.emplace_back([this]() {
12
                while (true) {
13
                    std::function<void()> task;
14
                    {
15
                        std::unique_lock lock(_mutex);
16
                        _cv.wait(lock, [this]{ return _stop || !_tasks.empty(); });
17
                        if (_stop && _tasks.empty()) return;
18
                        task = std::move(_tasks.front());
19
                        _tasks.pop();
20
                    }
21
                    task();
22
                }
23
            });
24
        }
25
    }
26

27
    template <typename F>
28
    auto submit(F&& func) -> std::future<decltype(func())> {
29
        using ReturnType = decltype(func());
30
        auto task = std::make_shared<std::packaged_task<ReturnType()>>(
31
            std::forward<F>(func)
32
        );
33
        auto future = task->get_future();
34
        {
35
            std::lock_guard lock(_mutex);
36
            _tasks.emplace([task]() { (*task)(); });
37
        }
38
        _cv.notify_one();
39
        return future;
40
    }
41

42
    ~ThreadPool() {
43
        {
44
            std::lock_guard lock(_mutex);
45
            _stop = true;
46
        }
47
        _cv.notify_all();
48
        for (auto& w : _workers) w.join();
49
    }
50
};
51

52
// 使用：
53
ThreadPool pool(std::thread::hardware_concurrency());
54

55
auto f1 = pool.submit([]{ return computePhysics(); });
56
auto f2 = pool.submit([]{ return computeAI(); });
57
auto f3 = pool.submit([]{ return computeAnimation(); });
58

59
// 等待所有结果
60
auto physics  = f1.get();
61
auto ai       = f2.get();
62
auto animation = f3.get();

1
// Single-Producer Single-Consumer 无锁环形队列
2
template <typename T, size_t Capacity>
3
class SPSCQueue {
4
    std::array<T, Capacity> _buffer;
5
    alignas(64) std::atomic<size_t> _head{0};  // 消费者读
6
    alignas(64) std::atomic<size_t> _tail{0};  // 生产者写
7
    // alignas(64)：放在不同缓存行，避免 false sharing
8

9
public:
10
    bool push(const T& item) {
11
        size_t tail = _tail.load(std::memory_order_relaxed);
12
        size_t next = (tail + 1) % Capacity;
13
        if (next == _head.load(std::memory_order_acquire)) {
14
            return false;  // 队列满
15
        }
16
        _buffer[tail] = item;
17
        _tail.store(next, std::memory_order_release);
18
        return true;
19
    }
20

21
    bool pop(T& item) {
22
        size_t head = _head.load(std::memory_order_relaxed);
23
        if (head == _tail.load(std::memory_order_acquire)) {
24
            return false;  // 队列空
25
        }
26
        item = _buffer[head];
27
        _head.store((head + 1) % Capacity, std::memory_order_release);
28
        return true;
29
    }
30
};
31

32
// 使用：主线程 ↔ 网络线程
33
SPSCQueue<NetworkMessage, 1024> net_to_main;
34
SPSCQueue<NetworkMessage, 1024> main_to_net;
35

36
// 网络线程
37
void networkThread() {
38
    while (running) {
39
        auto msg = receiveFromServer();
40
        net_to_main.push(msg);  // 无锁推送到主线程
41

42
        NetworkMessage outgoing;
43
        if (main_to_net.pop(outgoing)) {
44
            sendToServer(outgoing);  // 消费主线程发来的消息
45
        }
46
    }
47
}
48

49
// 主线程
50
void mainLoop() {
51
    NetworkMessage msg;
52
    while (net_to_main.pop(msg)) {  // 无锁消费
53
        processNetworkMessage(msg);
54
    }
55
}

1
class AsyncLoader {
2
    ThreadPool& _pool;
3
    std::unordered_map<std::string, std::shared_future<TexturePtr>> _pending;
4
    std::mutex _cache_mutex;
5

6
public:
7
    AsyncLoader(ThreadPool& pool) : _pool(pool) {}
8

9
    std::shared_future<TexturePtr> loadTexture(const std::string& path) {
10
        std::lock_guard lock(_cache_mutex);
11

12
        // 已经在加载中？返回相同的 future
13
        if (auto it = _pending.find(path); it != _pending.end()) {
14
            return it->second;
15
        }
16

17
        // 提交加载任务
18
        auto future = _pool.submit([path]() -> TexturePtr {
19
            auto data = readFile(path);          // IO（可能几十 ms）
20
            auto pixels = decodeImage(data);      // CPU 解码
21
            return createGPUTexture(pixels);       // 上传 GPU
22
        }).share();
23

24
        _pending[path] = future;
25
        return future;
26
    }
27
};
28

29
// 使用：
30
AsyncLoader loader(pool);
31
auto tex_future = loader.loadTexture("hero.png");
32

33
// 游戏循环中检查是否加载完成
34
if (tex_future.wait_for(std::chrono::milliseconds(0)) == std::future_status::ready) {
35
    auto texture = tex_future.get();
36
    sprite.setTexture(texture);  // 加载完成，使用纹理
37
} else {
38
    sprite.setTexture(placeholder);  // 还在加载，用占位图
39
}