图形渲染与 Shader / 系统课时

锁竞争为什么让多线程失效

锁竞争为什么让多线程失效

多线程并不等于并行。如果多个工作线程频繁争抢同一把锁,它们会从“同时计算”退化成“轮流进入临界区”。本课用线程时间线、等待时间和一个可运行示例判断锁竞争是否已经抵消并行收益,并给出适合游戏任务系统的修复顺序。

学习目标

  • 从线程状态与时间线识别锁竞争,而不是只看线程数量和总 CPU 利用率。
  • 理解临界区长度、访问频率和共享资源粒度如何决定等待成本。
  • 用缩小临界区、分片和批处理降低同步开销,并验证优化是否真的改善帧时间。

先确认是不是“线程很多但核心没在干活”

锁竞争最典型的现象是:任务被分发到多个线程,但同一时刻只有少数线程真正执行,其余线程处于等待、阻塞或被唤醒后的调度过程中。此时总 CPU 利用率可能并不低,因为线程切换和短暂运行也会消耗 CPU,所以不能只看一张利用率曲线。

分析一帧时,先在 CPU profiler 的线程时间线上找长条等待区,再向前追踪它在等哪把锁、锁由哪个线程持有,以及持锁线程在临界区里做了什么。如果多个工作线程的等待区都指向同一共享对象,基本可以确认并行度被这个共享点限制。

多线程锁竞争时间线

临界区为什么会吞掉并行收益

决定问题严重程度的不是“有没有锁”,而是锁被持有多久、每帧获取多少次,以及多少线程竞争同一把锁。临界区里如果包含内存分配、容器扩容、日志、资源查找或其他不可预测操作,持锁时间会被放大;高频短锁则可能把成本转移到原子操作、缓存一致性和线程唤醒上。

下面的程序对比两种做法:第一种每次递增都获取同一把互斥锁;第二种先在线程本地累计,最后只进入一次临界区。它不是游戏引擎基准,但能直接复现“共享写入把并行任务重新串行化”的核心现象。

cpp
#include <chrono>
#include <cstdint>
#include <iostream>
#include <mutex>
#include <thread>
#include <vector>

using Clock = std::chrono::steady_clock;

std::mutex g_mutex;
std::uint64_t g_counter = 0;

void contendedWorker(std::uint64_t iterations) {
    for (std::uint64_t i = 0; i < iterations; ++i) {
        std::lock_guard<std::mutex> lock(g_mutex);
        ++g_counter;
    }
}

void batchedWorker(std::uint64_t iterations) {
    std::uint64_t local = 0;
    for (std::uint64_t i = 0; i < iterations; ++i) {
        ++local;
    }

    // 只在提交最终结果时访问共享状态。
    std::lock_guard<std::mutex> lock(g_mutex);
    g_counter += local;
}

template <typename Worker>
long long runCase(Worker worker, int threadCount, std::uint64_t iterations) {
    g_counter = 0;
    std::vector<std::thread> threads;
    const auto start = Clock::now();

    for (int i = 0; i < threadCount; ++i) {
        threads.emplace_back(worker, iterations);
    }
    for (auto& thread : threads) {
        thread.join();
    }

    const auto end = Clock::now();
    const auto ms =
        std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();

    std::cout << "result=" << g_counter << ", elapsed=" << ms << " ms\n";
    return ms;
}

int main() {
    constexpr int kThreads = 4;
    constexpr std::uint64_t kIterations = 500000;

    std::cout << "contended: ";
    runCase(contendedWorker, kThreads, kIterations);

    std::cout << "batched: ";
    runCase(batchedWorker, kThreads, kIterations);
}

预期输出如下,<TIME> 受 CPU、编译优化和系统负载影响,实际数值可能不同;两组结果都应为 2000000,而批处理版本通常明显减少等待时间。

text
contended: result=2000000, elapsed=<TIME> ms
batched: result=2000000, elapsed=<TIME> ms

这个示例的关键不是“本地变量更快”,而是把共享写入从每线程 500000 次降到 1 次。游戏中的 Draw List、可见对象集合、事件队列和统计数据也常能用同样思路先在线程本地生产,再在较低频率下合并。

按持锁者而不是等待者定位

看到某个线程等待很久时,不要只分析这个等待线程。真正需要展开的是锁的持有者:它进入临界区前后执行了哪些函数,是否在锁内做了分配、I/O、资源创建,或者又去等待另一把锁。锁嵌套还可能形成锁队列,使一次慢操作传播到多个工作线程。

排查时可以按这个顺序收敛:先确认高等待占比,再定位竞争最重的锁;随后统计获取次数和持锁时长;最后检查共享数据是否真的必须由一把全局锁保护。若优化后只是把等待从一把锁搬到另一把锁,帧时间不会实质改善。

修复时优先减少共享

最有效的优化通常不是“换一把更快的锁”,而是减少多个线程同时修改同一份状态。适合游戏任务系统的做法包括把全局队列拆成每线程队列、按场景区域或资源类型分片、先写线程本地缓冲再批量合并,以及把只读数据发布成稳定快照。

缩小锁作用域也很重要。先在锁外准备数据,只把真正修改共享状态的几条操作放进临界区;如果容器可能扩容,应提前预留容量,避免把内存分配成本带进锁内。

用帧时间而不是微基准验收

修复后要回到原来的游戏场景,在相同相机路径、对象数量和任务配置下重新采样。至少比较主线程帧时间、工作线程阻塞时间、热点锁持有时长、上下文切换次数以及高分位帧时间,尤其关注 P95、P99 是否下降。

如果平均帧时间变好但 P99 仍然有尖峰,说明锁竞争可能只在资源切换、批量生成对象或 Streaming 高峰出现。最终目标不是让 profiler 里的某把锁“看起来更短”,而是让工作线程真正重叠执行,并让关键帧的等待链消失。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

锁竞争为什么让多线程失效

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通