条件竞争漏洞

条件竞争：

系统中，最小的运算调度单位是线程，而每个线程又依附于一个进程，条件竞争则是多进程或多线程对一个共享资源操作，因为操作顺序不受控的时候所产生的问题。

进程：

在计算机操作系统中，进程是指一个正在运行的程序的实例。它是操作系统进行资源分配和调度的基本单位。

进程的内存空间布局：

当操作系统启动一个进程时，会为它分配独立的虚拟内存空间。这个空间通常被划分为以下几个主要部分：

• 代码段（Text/Code Segment）： 存储程序执行的机器指令。这部分通常是只读的，以防止程序意外修改自己的指令。
• 数据段（Data Segment）： 存储程序中已经初始化的全局变量和静态变量。
• BSS 段（BSS Segment）： 存储程序中未初始化的全局变量和静态变量。在程序开始执行前，操作系统会将这块区域清零。
• 堆（Heap）： 用于程序运行时的动态内存分配堆的大小不固定，通常向高地址方向增长。
• 栈（Stack）： 用于存储局部变量、函数参数、局部代码块的上下文以及函数的返回地址。栈通常向低地址方向增长，由编译器自动分配和释放。

操作系统如何管理进程？

为了管理数量繁多的进程，操作系统会为每一个进程创建一个数据结构，称为 进程控制块 PCB。在 Linux 系统中，这个结构被称为 task_struct。PCB 包含了操作系统管理该进程所需的所有信息，主要包括：

• 进程标识符（PID, Process ID）： 每个进程独一无二的数字编号。
• 进程状态（State）： 记录进程当前处于什么阶段（如：运行中、就绪、阻塞/等待、终止）。
• CPU 寄存器状态： 当进程被暂停执行，发生上下文切换时，它的 CPU 寄存器（包括程序计数器 PC、栈指针 SP 等）的值会被保存在这里，以便下次恢复运行时能接着断点继续执行。
• 内存管理信息： 页表指针等，用于将进程的虚拟地址映射到物理内存。
• 资源清单： 进程打开的文件描述符（File Descriptors）、网络连接等。

线程

线程（Thread）是操作系统调度和分配 CPU 执行时间的最小单位。你可以把它理解为进程内部的一条独立执行流，可称为“轻量级进程（Lightweight Process）”

• 线程的是为了降低上下文切换的消耗，提高系统的并发性，并突破一个进程只能干一样事的缺陷，使到进程内并发成为可能；
• 线程是进程的一个实体，是 CPU 调度和分派的基本单位，它是比进程更小的能独立运行的基本单位；
• 线程自己基本上不拥有系统资源，只拥有在运行中必不可少的资源 (如程序计数器、一组寄存器和栈)，但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源；
• 线程间通信主要通过共享内存，上下文切换很快，资源开销较少，但相比进程不够稳定容易丢失数据；

协程

协程（Coroutine），又称为微线程，是一种用户态的轻量级线程。

如果说进程和线程的调度都是由操作系统（OS）内核强制接管的，那么协程的调度则是完全交由程序代码本身来控制的。

让我们继续用“工厂”来打比方：

• 进程（Process）：工厂。
• 线程（Thread）：工厂里的工人。操作系统负责分配工人去哪个流水线。
• 协程（Coroutine）：当一个工人在烤箱前等待零件加热（I/O 阻塞）时，他不会傻站着，而是主动放下当前的活，转头去另一条流水线上拧螺丝；等烤箱“叮”了一声（I/O 完成），他再回来接着处理加热好的零件。
• 协程通过在线程中实现调度，避免了陷入内核级别的上下文切换造成的性能损失，进而突破了线程在 IO 上的性能瓶颈；
• 协程拥有自己的寄存器上下文和栈；
• 协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈，直接操作栈则基本没有内核切换的开销；

并发编程

• 目的：并发编程在实际情况是为了提高执行效率，提高系统的利用率；
• CPU 的速度远快于各种 IO，而这也导致了 CPU 在很多时候，都是在持续等待中；
• 然而如果利用分时的机制，这样可以让 CPU 将不同时间片分发给不同的 task，这样就能大大的提示 CPU 的利用率；

而且这种机制也可以让多个程序分开执行不同任务；

• 从整个程序执行角度来看，程序执行时可以看作是对输入的数据进行计算处理然后输出到特定的设备中
• 当其中的一个环节正在执行的时候其他环节就会挂起；
• 一旦输入阻塞，即 IO 等待读入数据，那么已读入的数据也不能得到处理，已处理的数据也不能输出，这就造成了 CPU 的闲置；
• 如果这三个步骤可以并发执行的话，即使 IO 在等待输入，CPU 仍然可以对已在内存中的数据做计算处理，结果也可以正常输出；
• 这就提高了 CPU 的利用率，不会因为输入输出的阻塞，导致 CPU 的计算能力被浪费；
• 当有多种类型的任务执行时，为每种任务单独编写程序，比编写混杂在一起的所有任务的程序，要简单的多；

pthread_create 与 pthread_join

这两个函数在多线程编程中是形影不离的搭档。简单来说，它们的关联就像是”分配任务”与”等待汇报并清理工位”

我们可以从以下三个核心维度来理解它们之间密不可分的关联：

1. 生命周期管理：创建与回收

• pthread_create (产生)：它的作用是向操作系统申请资源（比如分配线程栈、TLS 线程局部存储等），并启动一个新的线程去独立执行指定的函数。
• pthread_join (回收)：当子线程执行完毕退出后，它其实并没有彻底消失，而是会进入一种类似进程中的“僵尸 Zombie 状态”，保留着它的退出状态码和部分系统资源。pthread_join 的核心作用之一就是去收集这个退出状态，并彻底释放该线程占用的所有残留系统资源。
• 关联：就像 malloc 对应 free，或者是多进程里的 fork 对应 waitpid 一样。如果一个线程被 pthread_create 出来，主线程就必须调用 pthread_join，否则会导致内存和系统资源泄漏。

2. 执行流程的同步：异步并发与强制等待

• pthread_create 调用后会立刻返回，主线程和新创建的子线程会开始并发且异步执行，各跑各的。
• 但是在很多业务场景下，主线程需要等待子线程把活干完，才能继续往下走。这时候主线程调用 pthread_join (目标线程ID)，主线程就会阻塞，暂停执行在这个函数上。直到目标线程彻底运行结束，pthread_join 才会返回，主线程才会继续执行下一行代码。
• 关联：pthread_join 是协调多个并发线程执行顺序的最基础手段，把并行的乱序执行强行拉回到同步轨道上

3. 数据的传递：获取子线程的执行结果

• pthread_create 可以通过最后一个参数向子线程传递参数。
• 子线程执行完毕时，可以通过 return 或者 pthread_exit() 返回一个指针（通常指向运算结果）。
• pthread_join 的第二个参数（一个二级指针）就是用来接收子线程返回的这个结果指针的。

---

例举一个有关两个函数的例子：

if ( pthread_create(&newthread, 0, start_routine, 0) < 0 )
{
    puts("Internal error, contact admin.");
    exit(1);
}
pthread_join(newthread, 0);
return 0; // main 函数结束

1. 分配任务：主线程通过 pthread_create 创建了 newthread，让它去执行 start_routine函数
2. 强制等待：紧接着主线程立刻调用了 pthread_join(newthread, 0)。这意味着主线程啥也不干了，就死死卡在这里，等待函数操作完毕并退出。
3. 防止程序提前崩溃：如果这里没有 pthread_join，主线程在 pthread_create 后会直接执行 return 0，导致整个进程直接退出。进程一旦退出，里面的所有子线程不管有没有执行完，都会被操作系统直接强行杀死。所以这里的 join 是为了保证程序的菜单能够持续运行并接收用户输入。

条件竞争产生的条件

并发，即至少存在两个并发执行流，这里的执行流包括线程、进程、任务等级别的执行流；

共享对象，即多个并发流会访问同一对象

常见的共享对象有共享内存、文件系统、信号，这些共享对象是用来使得多个程序执行流相互交流

改变对象，即至少有一个控制流会改变竞争对象的状态；如果程序只是对对象进行读操作，那么并不会产生条件竞争；

这里例举一个例子：

/* 引入 POSIX 线程（Pthreads）库的头文件。
  告诉编译器我们将使用与线程相关的函数（如 pthread_create 和 pthread_join）和数据类型。 */
#include <pthread.h>
#include <stdio.h>

/* 声明了一个全局整型变量。
   它被存放在 BSS 段（未初始化数据段），默认初始化为 0。
   这个变量存在于全局内存中，所有稍后创建的线程都将共享、读取和修改这同一个内存地址*/
int counter;

// 定义了线程启动后要执行的工作函数。
void *IncreaseCounter(void *args) {

  counter += 1;
  
  /*  C 标准库的 sleep() 只接受无符号整数。
      传入浮点数 0.1 会发生隐式类型转换，被截断为 sleep(0)。
      这实际上起到了 Yield（主动让出 CPU 时间片）的作用，放大了并发冲突的概率 */
  sleep(0.1);
  
  // 打印当前执行状态。
  // pthread_self() 获取当前线程的 ID，将其强制转换为 unsigned int 匹配 %d 打印。
  // 此时读取到的 counter 往往已经被其他并发线程修改过了。
  printf("Thread %d has counter value %d\n", (unsigned int)pthread_self(),
         counter);
}

// 主线程
int main() {
  
  // 声明了一个包含 10 个元素的数组，用于保存即将创建的 10 个子线程的唯一标识符（ID）。
  pthread_t p[10];
  
  // 循环 10 次，向操作系统申请创建 10 个新线程。
  for (int i = 0; i < 10; ++i) {
    // &p[i]           : 将新创建的线程 ID 保存到数组中。
    // NULL            : 线程属性，传 NULL 表示使用系统默认属性。
    // IncreaseCounter : 指定新线程启动后要去执行的函数指针。
    // NULL            : 传递给 IncreaseCounter 函数的参数（此处无需传参）。
    pthread_create(&p[i], NULL, IncreaseCounter, NULL);
  }
  
  // 再次循环 10 次，阻塞主线程，等待所有子线程执行完毕。
  for (int i = 0; i < 10; ++i) {
    // p[i] : 要等待的子线程 ID。
    // NULL : 用于接收子线程退出时的返回值（此处不关心，填 NULL）。
    // 如果没有 join，主线程可能会在子线程执行完之前就直接退出，导致整个进程被销毁。
    pthread_join(p[i], NULL);
  }
  return 0;
}

一般来说，我们可能希望按如下方式输出：

➜  005race_condition ./example1
Thread 1859024640 has counter value 1
Thread 1841583872 has counter value 2
Thread 1832863488 has counter value 3
Thread 1824143104 has counter value 4
Thread 1744828160 has counter value 5
Thread 1736107776 has counter value 6
Thread 1727387392 has counter value 7
Thread 1850304256 has counter value 8
Thread 1709946624 has counter value 9
Thread 1718667008 has counter value 10

但是，由于条件竞争的存在，最后输出的结果往往不尽人意：

➜  005race_condition ./example1
Thread 1417475840 has counter value 2
Thread 1408755456 has counter value 2
Thread 1391314688 has counter value 8
Thread 1356433152 has counter value 8
Thread 1365153536 has counter value 8
Thread 1373873920 has counter value 8
Thread 1382594304 has counter value 8
Thread 1400035072 has counter value 8
Thread 1275066112 has counter value 9
Thread 1266345728 has counter value 10

之所以会出现这么多 8，
    核心原因在于：printf 打印的不是“刚才我加完之后的那个数字”，
    而是“此时此刻全局共享内存里 counter 的最新状态”。
    
假设这 6 个打印出 8 的线程是线程 C、D、E、F、G、H。

第一步: 加数字，但都不马上打印

    线程 C 被 CPU 叫醒，执行了 counter += 1。此时内存里的 counter 可能变成了 3。
    紧接着，线程 C 碰到了 sleep(0)，它主动放弃了 CPU：“我休息一下，你们先上”。
    随后，线程 D、E、F、G、H 像接力赛一样，快速地被 CPU 调度。它们每个人都跑过去把 counter 加了 1，然后立刻 sleep(0) 挂起。
    在这个短暂的瞬间，由于大家都在疯狂做加法，全局变量 counter 的值被迅速推高到了 8。

第二步: 集体醒来

    现在，这 6 个刚才被挂起的线程（C 到 H）陆续醒来了，准备执行下一行代码，也就是 printf。
    printf 函数需要读取 counter 的值。于是，线程 C 跑去看全局内存（黑板），发现上面的数字已经是 8 了，于是它诚实地打印出：“我的 counter 值是 8”。
    接着，线程 D 醒来，也跑去看内存。因为这期间没有别的线程去修改 counter（或者别的线程还没赶到加法那一步），内存里依然是 8，于是 D 也打印：“我的也是 8”。
    依此类推，这 6 个线程在打印时，读取到的是同一个“已经长大的”全局变量，所以它们都整整齐齐地输出了 8。

仔细思考一下条件竞争为什么可能会发生呢？以下面的为具体的例子

• 程序首先执行了 action1，然后执行了 action2。其中 action 可能是应用级别的，也可能是操作系统级别的。正常来说，我们希望程序在执行 action2 时，action1 所产生的条件仍然是满足的。
• 但是由于程序的并发性，攻击者很有可能可以在 action2 执行之前的这个短暂的时间窗口中破坏 action1 所产生的条件。这时候攻击者的操作与 action2 产生了条件竞争，所以可能会影响程序的执行效果。

所以我认为问题的根源在于程序员虽然假设某个条件在相应时间段应该是满足的，但是往往条件可能会在这个很小的时间窗口中被修改。虽然这个时间的间隔可能非常小，但是攻击者仍然可能可以通过执行某些操作（如计算密集型操作，Dos 攻击）使得受害机器的处理速度变得相对慢一些。

程序详细运行过程：

数据竞争（Data Race）

这个程序的运行过程并不是线性的，而是充满着不确定性。以下是该程序从启动到结束的详细运行图景：

1. 程序的启动与初始化
- 当程序开始运行时，操作系统会为其分配内存。全局变量 `counter` 被放置在 BSS 段，并自动初始化为 `0`。
- 操作系统的进程调度器启动主线程（Main Thread），也就是开始执行 main() 函数。

2. 子线程的批量诞生
- 主线程进入第一个 `for` 循环。它连续 10 次调用 `pthread_create` 向操作系统申请创建新的子线程。
- 此时，操作系统内核会快速拉起 10 个子线程。需要特别注意的是：线程一旦被创建，它就立刻进入了‘就绪’状态，随时可能被 CPU 调度执行。
- 因此，当主线程还在循环创建第 5 个、第 6 个线程时，前面创建的第 1、第 2 个线程很可能已经开始执行 `IncreaseCounter` 函数了。它们是完全并发的。

3. 并发执行与“数据踩踏”
这是整个代码中最关键、也最混乱的阶段。这 10 个子线程都会去执行 `IncreaseCounter`。我们拆解一下在这个函数里到底发生了什么：

* **读取与修改（隐患所在）：**
    代码执行了 `counter += 1;`。在 CPU 看来，这不是一个一气呵成的操作，它分为三步：
    1. 从内存中读取 `counter` 的值到寄存器。
    2. 在寄存器中将该值加 1。
    3. 将寄存器的新值写回到内存中的 `counter` 地址。
    *如果线程 A 刚读出 0 还没来得及加 1，线程 B 也读出了 0，那么它们最终都会把 1 写回内存，导致一次加法操作丢失。

* **主动让出 CPU（放大隐患）：**
    代码调用了 `sleep(0.1)`，由于类型截断变成了 `sleep(0)`。这在操作系统中的语义通常是**“主动放弃当前剩余的 CPU 时间片（Yield）”**。
    这意味着：线程 A 刚刚费劲地把 `counter` 加了 1，还没来得及打印，就被迫挂起了。CPU 瞬间切换给线程 B、C、D 去执行。这大大增加了多个线程在同一时间段内读取和修改 `counter` 的概率。

* **滞后的打印：**
    等到线程 A 再次被操作系统唤醒，终于走到 `printf` 这一行时，全局的 `counter` 可能已经被刚才趁机运行的线程 B、C、D 修改过好多次了。
    **结果就是：** 线程 A 本来是在 `counter` 变成 1 的时候执行的加法，但它打印出来的值可能是 4，也可能是 10。

4. 主线程的阻塞与等待
- 当主线程完成 10 次创建后，它进入第二个 `for` 循环，调用 `pthread_join`。
- `pthread_join` 是一个阻塞函数。主线程会在这里“停住”，死死盯着 `p[0]` 这个线程，直到它彻底执行完毕才放行。然后接着等 `p[1]`，依此类推。
- 如果没有这一步，主线程的 `main` 函数可能会瞬间执行完毕并 `return 0`。一旦主线程（即进程主体）退出，所有还没来得及干活的子线程也会被操作系统强行全部杀掉（销毁）。

5. 程序的落幕
* 当这 10 个子线程经历了混乱的读写、让出 CPU、乱序打印，并且全部退出后，主线程的 10 次 `pthread_join` 也全部完成。
* 主线程执行 `return 0`，整个进程结束，操作系统回收所有相关的内存和资源。

---

看到的现象：
如果你运行这段代码，看到的终端输出绝对不是整齐的 `counter value 1` 到 `10`。
你会看到乱序的线程 ID，且打印出的 `counter` 值大概率有很多重复的数字（比如好几个线程都打印出 `10`），这就是没有使用锁（Lock）保护共享资源所付出的代价。

互斥锁保护：

#include <pthread.h>
#include <stdio.h>
#include <unistd.h> // sleep 函数所在的头文件

int counter;

// 1. 声明并初始化一个全局的互斥锁
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;

void *IncreaseCounter(void *args) {
    // 2. 加锁（进入临界区）
    // 如果锁已经被别的线程拿走了，当前线程就会在这里阻塞（排队等待），直到锁被释放。
    pthread_mutex_lock(&lock);

    /* ---------------- 临界区开始 ---------------- */
    
    counter += 1;
    
    // 即使这里主动让出 CPU，其他线程依然进不来，因为当前线程手里死死攥着锁！
    sleep(0); 
    
    // 把打印也放在锁里，确保打印出的 counter 值是当前线程刚刚修改完的准确值
    printf("Thread %u has counter value %d\n", (unsigned int)pthread_self(), counter);

    /* ---------------- 临界区结束 ---------------- */

    // 3. 解锁（离开临界区）
    // 把锁还给操作系统，唤醒外面正在排队等待的其他线程。
    pthread_mutex_unlock(&lock);

    return NULL;
}

int main() {
    pthread_t p[10];

    for (int i = 0; i < 10; ++i) {
        pthread_create(&p[i], NULL, IncreaseCounter, NULL);
    }

    for (int i = 0; i < 10; ++i) {
        pthread_join(p[i], NULL);
    }

    // 4. 销毁锁，释放资源（好习惯）
    pthread_mutex_destroy(&lock);

    return 0;
}

更新: 2026-04-19 11:32:54
原文: https://www.yuque.com/idcm/wnemg9/fk8msxuai0u2ggno