Threads

Thread Concept#

线程（Thread）是 CPU 使用的基本单位，也是进程中的一条执行流。 一个进程可以只有一个线程，也可以包含多个线程。

每个线程有自己的：

• 线程 ID：标识这条执行流。
• 程序计数器（Program Counter，PC）：记录当前执行位置。
• 寄存器组：保存计算过程中使用的状态。
• 栈（Stack）：保存函数调用、返回地址和自动局部变量等信息。

同一进程内的线程共享代码、全局数据、堆、地址空间以及打开的文件等进程资源。

因此，同一段函数代码可以由多个线程执行；各线程可以处于不同的执行位置，使用各自的参数与调用栈。

Example#

A Responsive Web Browser

从一个简化浏览器出发，说明为什么需要多条执行流。浏览器需要获取数据、显示内容、处理用户输入。

第一版：依次完成三项操作。

1
// 每项操作都可能占用或阻塞约 1 秒
2
while (true) {
3
    RetrieveData();
4
    DisplayData();
5
    GetInputEvents();
6
}

一轮约需 3 秒。程序处于获取、显示阶段时，新的输入不能及时交给 GetInputEvents() 处理，用户会感到界面卡顿。

第二版：把每项操作拆小。

1
// 每次只处理一小部分，约 0.1 秒
2
while (true) {
3
    RetrieveALittleData();
4
    DisplayALittleData();
5
    GetAFewInputEvents();
6
}

一轮缩短到约 0.3 秒，检查输入的间隔减小。但开发者必须手工保存每个任务的进度，并把长操作拆成许多可暂停的小步骤。

第三版：先检查，再处理。

1
// 伪代码
2
while (true) {
3
    if (CheckData()) {
4
        RetrieveALittleData();
5
        DisplayALittleData();
6
    }
7
    if (CheckInputEvents()) {
8
        GetAFewInputEvents();
9
    }
10
}

轮询减少了部分无效处理，但频繁检查本身有开销；某一步一旦执行过久，其他工作仍要等待。为了提高响应性，希望每块工作很小；为了降低管理开销，又希望一次能处理足够多的工作。

第四版：使用多个线程。

1
// 伪代码：传入线程入口函数，具体 API 参数后面再讨论
2
main() {
3
    CreateThread(RetrieveData);
4
    CreateThread(DisplayData);
5
    CreateThread(GetInputEvents);
6
    WaitForThreads();
7
}
8

9
RetrieveData() {
10
    while (true) {
11
        retrieveData();
12
        // 更新数据，必要时等待 I/O
13
    }
14
}
15

16
DisplayData() {
17
    while (true) {
18
        displayData();
19
        // 根据已有数据刷新显示
20
    }
21
}
22

23
GetInputEvents() {
24
    while (true) {
25
        getInputEvents();
26
        // 接收并处理用户操作
27
    }
28
}

三项工作分别保存自己的执行状态，由线程库和操作系统安排执行机会。在支持相应阻塞与调度的实现中，获取数据的线程等待 I/O 时，输入线程仍可以运行。

Benefits#

多线程的四项主要优势：

1. 响应性（Responsiveness）：把耗时操作交给工作线程，界面线程可以继续响应输入。
2. 资源共享（Resource Sharing）：线程天然共享所属进程的内存和资源，便于协作处理同一份数据。
3. 经济性（Economy）：线程创建和同一进程内的线程切换通常比创建、切换进程更轻量，因为可以复用已有地址空间与资源。
4. 利用多处理器（Utilization of MP Architectures）：在映射模型与硬件支持下，把不同线程分配到不同处理器或核心上并行运行。

线程创建、调度、同步都存在开销；线程数量增加不保证程序按比例加速。

Threads and Processes#

理解二者时，分别关注资源组织与执行状态：

• 进程组织地址空间、代码、数据和打开的文件等资源。不同进程通常具有独立地址空间。
• 线程在进程内执行代码，拥有自己的 PC、寄存器和栈；同一进程中的线程可以直接访问共同数据。
• 进程间通信通常需要显式建立共享内存、管道、消息等机制。共享内存建立后，对共享区域的普通读写无需每次都进入内核。
• 线程间协作较方便，但错误的共享访问也容易相互影响。一个线程破坏进程内存，可能导致整个进程出错。

Concurrency and Parallelism#

并发（Concurrency）：多项工作在一段时间内都能推进，例如单核 CPU 交替运行多个线程。

并行（Parallelism）：多项工作在同一时刻执行，例如两个核心各运行一个线程。

单核也能从多线程中受益：一个线程等待 I/O 时，另一个就绪线程可以使用 CPU。但对于完全依赖 CPU 的计算，单核不能仅靠增加线程得到多核式并行加速。

User Threads and Kernel Threads#

用户线程（User Thread） 由用户空间的线程库提供和管理。纯用户级实现可以在用户空间保存线程状态、选择下一条用户执行流，无需让内核逐一管理这些用户线程。

内核线程（Kernel Thread） 由操作系统内核支持和管理，内核能够分别调度这些执行实体。

线程 API 规定怎样使用线程；映射模型规定用户执行流怎样对应内核调度实体。

Many-to-One#

多个用户线程映射到一个内核线程。

• 用户线程库在用户空间完成管理和切换，通常开销较小。
• 内核只看到一个执行实体，同一时刻这组用户线程最多有一个在执行，无法利用多个核心并行运行。
• 如果某个用户线程发起的系统调用实际阻塞了唯一的内核线程，其余用户线程也无法继续运行。

One-to-One#

每个用户线程对应一个内核线程。

• 某个线程等待 I/O 时，其他就绪线程仍可被内核调度。
• 多个线程可以在多个核心上并行运行。
• 创建用户线程通常还需要创建对应的内核线程，线程过多会增加内存、调度和管理开销，数量也受到系统资源限制。

Many-to-Many#

多个用户线程复用多个内核线程。 设用户线程数为 $U$、内核线程数为 $K$，模型通常满足 $K\le U$。

用户线程库把就绪的用户线程安排到可用的内核执行实体上，内核再把这些实体安排到 CPU 上。

• 用户线程数量与内核线程数量可以分开管理。
• 多个内核线程可以并行运行；某个内核线程阻塞时，其他可用的内核线程仍能推进工作。
• 需要协调用户线程库和内核调度，设计与实现更复杂。

映射可以动态变化，图中的连线不表示每个用户线程永久绑定一个内核线程。若所有可用内核线程都阻塞，其他用户线程仍会缺少执行资源。

Two-level Model#

双层模型在多对多的基础上，允许某些用户线程绑定到特定内核线程。

普通用户线程仍动态复用内核线程；被绑定的用户线程具有固定的内核执行实体。这样可以为有特殊调度需求的线程保留更直接的内核调度关系。

绑定内核线程与绑定物理 CPU 是不同操作。 有了固定映射，也仍需要内核调度；是否满足实时期限还取决于调度策略、负载等条件。

Model Comparison#

Example#

Available Parallelism

一个进程有 8 个用户线程，机器提供 4 个可同时执行线程的 CPU 资源。所有线程均就绪、工作彼此独立，分别采用多对一、一对一，以及配有 2 个内核线程的多对多模型。同一时刻最多有几个线程执行？

Semantics of fork() and exec()#

多线程进程调用 fork() 时，需要考虑：子进程中保留多少条执行流？

有两种历史设计：只复制调用 fork() 的线程，或复制进程中的全部线程。

POSIX/Linux 的 fork() 采用只复制调用线程的语义。 父进程的其他线程继续存在；子进程获得父进程地址空间的副本，但子进程中只有调用线程的那条执行流。

exec() 成功后替换整个进程映像，原有的其他线程终止，新程序从自己的入口开始执行。 进程 PID 保持不变，旧程序不会接着执行 exec() 后的语句；调用失败时才返回错误。

Thread Cancellation#

线程取消（Thread Cancellation） 是在目标线程自然完成之前，请求终止它。例如，多个线程同时搜索，找到结果后取消剩余搜索；用户停止网页加载，取消还在工作的下载线程。

两种主要方式：

• 异步取消（Asynchronous Cancellation）：目标线程可能在执行过程中的任意位置被终止，响应直接，但容易打断资源管理或共享数据更新。
• 延迟取消（Deferred Cancellation）：提出取消请求后，目标线程到达规定的检查位置再处理请求，便于安排清理工作。

Pthreads 中，pthread_cancel(tid) 提交取消请求。

默认情况下允许取消，并采用延迟取消；目标线程在**取消点（Cancellation Point）**处理请求，例如 read()、pthread_join() 或显式调用 pthread_testcancel() 时。

1
// 工作线程中的示意片段
2
while (true) {
3
    do_one_safe_work_unit();
4
    pthread_testcancel();  // 允许取消且存在待处理请求时，在这里终止
5
}

取消点可能位于库函数内部，无需把延迟取消理解为每次都手工读取一个普通布尔变量。

pthread_cancel() 成功返回，也不保证目标已经结束；

需要确认结束时，可再等待 pthread_join()。取消被禁用时，请求可以保持待处理状态。

Signal Handling#

**信号（Signal）**用于通知进程某个事件已经发生，基本过程是：产生信号 → 交付给目标 → 按相应方式处理。

按来源理解：

• 同步信号由当前执行的操作引起，例如某些非法内存访问、整数除零异常，应交给触发事件的线程处理。
• 异步信号来自当前执行之外的事件，例如终端的 Ctrl+C、定时器到期或其他进程发送信号。

处理方式包括系统规定的默认动作、程序注册的处理函数，以及对允许忽略的信号采取忽略动作。某些信号，如 SIGKILL 和 SIGSTOP，不能被捕获或忽略。

多线程程序的额外问题是：一个进程里有多个线程，信号交给谁？ 四种设计选择：

1. 交给信号所针对的线程。
2. 交给进程内所有线程。
3. 交给进程内某一组线程。
4. 指定一个线程集中接收、处理相应信号。

对 POSIX/Linux 的常见行为，还应区分：

• 信号处理方式由进程内线程共享；哪些信号暂时被屏蔽，则由每个线程自己的信号掩码决定。
• 线程定向信号交给指定线程，例如使用 pthread_kill() 指定目标。
• 进程定向信号通常交给一个未屏蔽该信号的合适线程；不会自动让每个线程各运行一次处理函数。
• 集中处理通常针对预先协调屏蔽的一组异步信号，例如由专门线程调用 sigwait() 等待；同步异常仍需要按其触发线程处理。

信号的默认动作可能终止整个进程，这与“每个线程各处理一次信号”是两回事。

Thread Pools#

如果每收到一个请求就创建一个线程，请求很多时，会反复付出创建开销，还可能耗尽内存和调度资源。

线程池（Thread Pool） 预先创建一组工作线程，反复复用：

1. 工作线程等待任务。
2. 新请求到来后提交任务。
3. 有空闲线程时，由该线程执行；暂时没有空闲线程时，任务通常进入队列。
4. 任务结束后，工作线程继续等待下一项任务。

主要优势是减少反复创建线程的开销、控制工作线程数量，以及将任务提交与线程管理分开。

Thread-Specific Data#

共享地址空间便于协作，但有些状态需要每个线程单独保存，例如各线程的统计计数、错误信息或当前处理任务的上下文。

**线程特定数据（Thread-Specific Data）／线程局部存储（Thread-Local Storage，TLS）**允许不同线程通过相同的名称或键，访问各自对应的数据。

• 普通全局变量：线程访问同一个对象，适合共享状态；并发读写需要同步。
• 普通自动局部变量：属于某次函数调用，常存放在该线程的栈上。
• TLS：按线程分别保存，可以跨越多次函数调用持续使用。

1
// C++ 补充示例：每个线程都有自己的 processed_count
2
thread_local int processed_count = 0;
3

4
void record_one_task() {
5
    ++processed_count;
6
}

线程 A 增加自己的计数，不会直接改变线程 B 的计数。若 TLS 中保存的是指针，两个线程的指针仍可能指向同一个共享对象，需要继续分析对象本身是否共享。

Scheduler Activations#

多对多与双层模型有两层调度：用户线程库安排用户线程，内核安排内核线程。

两层需要交换信息，才能知道哪些用户线程阻塞、哪些执行资源仍可使用。

轻量级进程（Lightweight Process，LWP） 表示用户线程与内核线程之间的执行资源抽象：

• 对用户线程库，LWP 像一个可以安排用户线程运行的虚拟处理器。
• 每个 LWP 关联一个内核线程。
• 内核把内核线程调度到真实处理器上。

当关联的内核线程阻塞时，LWP 及其承载的用户线程也会失去执行机会。这里的 LWP 用法对应多对多模型。

调度器激活（Scheduler Activations） 通过内核与线程库的协作，协调可用虚拟处理器及用户线程状态。

内核向用户线程库发送的通知称为 上调（Upcall），由线程库的 upcall handler 处理。例如某线程将要阻塞时：

1. 内核通知线程库：哪个用户线程将要阻塞。
2. 内核提供新的虚拟处理器来运行处理函数。
3. 线程库保存相应状态，并选择其他就绪用户线程运行。
4. 原来等待的事件完成后，内核再次通知线程库，将该用户线程恢复为可调度状态。

内核掌握阻塞与处理器分配情况，线程库掌握应用内的用户线程安排；upcall 把两类信息连接起来。 增加虚拟处理器仍需复用真实 CPU，不会增加物理核心数量。

API and Implementation#

Pthreads 是 POSIX 规定的线程创建、管理与同步 API。

规范规定接口行为，具体怎样组织线程、怎样与内核协作，由实现决定。它常见于 Linux、Solaris、macOS 等 UNIX 类系统。

Example#

Summation in a Worker Thread

创建一个工作线程计算 $1+2+\cdots+N$，主线程等待计算结束，再输出结果。

把输入固定为 N = 5，使用默认线程属性，并补上关键返回值检查，便于观察线程机制。

1
#include <pthread.h>
2
#include <stdio.h>
3

4
static long sum = 0;  // 同一进程中的线程共享
5

6
static void *runner(void *arg) {
7
    int upper = *(int *)arg;
8
    for (int i = 1; i <= upper; ++i) {
9
        sum += i;
10
    }
11
    return NULL;  // 结束当前工作线程
12
}
13

14
int main(void) {
15
    int upper = 5;
16
    pthread_t tid;
17

18
    int rc = pthread_create(&tid, NULL, runner, &upper);
19
    if (rc != 0) {
20
        fprintf(stderr, "pthread_create failed: %d\n", rc);
21
        return 1;
22
    }
23

24
    rc = pthread_join(tid, NULL);
25
    if (rc != 0) {
26
        fprintf(stderr, "pthread_join failed: %d\n", rc);
27
        return 1;
28
    }
29

30
    printf("sum = %ld\n", sum);
31
    return 0;
32
}

1
pthread_create(&tid, NULL, runner, &upper);

1
sum = 15

Thread Attributes#

原程序使用 pthread_attr_t 显式保存属性：

1
// 核心调用示意：假设调用成功，tid、runner 和 upper 已定义
2
pthread_attr_t attr;
3
pthread_attr_init(&attr);  // 初始化为默认属性
4
pthread_create(&tid, &attr, runner, &upper);
5
pthread_attr_destroy(&attr);

属性可用于描述栈大小、分离状态及相关调度设置。只需要默认设置时，创建函数的第二个参数可直接传 NULL。

销毁属性对象不等于销毁线程；线程创建时已经使用相应属性完成设置。

Joining and Termination#

pthread_join(tid, ...) 等待指定的可连接线程结束。 若目标已结束，可以立即返回；若尚未结束，等待的是调用者。线程创建后，主线程与工作线程谁先执行没有一般保证。

等待多个线程时，通常先创建全部工作线程，再逐个 join：

1
// 核心结构示意：假设每次创建都成功，参数对象保持有效
2
for (int i = 0; i < n; ++i)
3
    pthread_create(&tids[i], NULL, worker, &args[i]);
4

5
for (int i = 0; i < n; ++i)
6
    pthread_join(tids[i], NULL);

第二个循环按顺序等待，不要求线程按同一顺序运行或完成。如果把创建与立即等待放进同一个循环，就会等一个完成后才创建下一个，限制这批工作的并发。

结束线程时还要区分：

• 在非主线程的入口函数中 return value，或调用 pthread_exit(value)：结束当前线程。
• main() 返回，或调用 exit()：结束整个进程。
• 主线程调用 pthread_exit()，其他线程可以继续运行；但不能继续访问已经失效的主线程栈对象。

若通过退出值返回指针，也必须保证指向的对象在线程结束后仍然有效。

Example#

Threads and Process Address Spaces

初始全局变量 value = 0。程序先 fork()；子进程创建一个线程，把 value 改为 5，并在 join() 后输出。父进程等待子进程结束后，再输出自己的 value。两处结果分别是什么？

1
// 题目核心逻辑
2
int value = 0;
3

4
void *runner(void *arg) {
5
    (void)arg;
6
    value = 5;
7
    return NULL;
8
}
9

10
int main(void) {
11
    pid_t pid = fork();
12
    if (pid == 0) {
13
        pthread_t tid;
14
        pthread_create(&tid, NULL, runner, NULL);
15
        pthread_join(tid, NULL);
16
        printf("CHILD: value = %d\n", value);
17
    } else if (pid > 0) {
18
        wait(NULL);
19
        printf("PARENT: value = %d\n", value);
20
    }
21
    return 0;
22
}

1
CHILD: value = 5
2
PARENT: value = 0

Mapping and Thread Context#

Windows XP 采用一对一映射。线程包含线程 ID、PC 与寄存器状态、用户栈、内核栈，以及私有数据存储区。

• 用户栈用于执行用户态代码时的调用与局部状态。
• 内核栈用于该线程进入内核执行时的调用与局部状态。
• 私有数据区可保存运行库使用的信息及线程局部数据。

这些寄存器、栈与私有数据等构成线程的上下文（Context）。同一线程在用户态与内核态之间切换，不代表又创建了一条线程。

Thread Data Structures#

Example#

Thread Creation with the Windows API

1
// 文件作用域声明；需要 windows.h
2
DWORD Sum = 0;
3

4
DWORD WINAPI Summation(LPVOID param) {
5
    DWORD upper = *(DWORD *)param;
6
    for (DWORD i = 1; i <= upper; ++i)
7
        Sum += i;
8
    return 0;
9
}
10

11
// 以下语句位于调用线程的函数中
12
DWORD upper = 5;
13
DWORD thread_id;
14
HANDLE handle = CreateThread(
15
    NULL, 0, Summation, &upper, 0, &thread_id
16
);
17
WaitForSingleObject(handle, INFINITE);
18
CloseHandle(handle);
19
// 此后读取 Sum，得到 15

Tasks and Resource Sharing#

Linux 内核用统一的 **任务（Task）**结构描述可调度的执行实体，每个任务有自己的 task_struct，通过关联的数据结构记录地址空间、打开的文件、信号处理等信息。

• 创建独立进程时，新任务具有相应的独立地址空间及资源状态。
• 创建同一进程内的线程时，各任务共享地址空间及多项进程资源，但各自保留执行状态并参与调度。

The clone() System Call#

clone() 可以创建新任务，并通过标志指定它与调用者共享哪些资源。

四项典型标志：

新任务的相关指针可以指向已有资源结构，由此实现共享。对于未选择共享的资源，则按接口规定建立相应的独立状态。

这些标志用于说明资源共享机制，单凭这四项还不能完整描述一个 POSIX 线程。 例如，CLONE_THREAD 用于让新任务加入同一个线程组；即使共享信号处理方式，各线程仍有自己的信号掩码。

Relationship with Pthreads#

应用使用 pthread_create()，线程库完成属性、栈及运行时状态的管理，再利用 Linux 的 clone 相关机制建立内核任务。

因此，pthread_create() 是应用可见的线程 API，clone() 是底层提供任务创建与资源共享能力的机制。Linux/glibc 的 NPTL 采用一对一模型；无需由应用直接拼装全部 clone 标志来使用普通 POSIX 线程。

JVM and Thread Creation#

Java 线程由 **Java 虚拟机（JVM）**提供创建与管理接口，具体怎样映射到宿主系统的线程，由 JVM 实现决定。

两种显式创建方式：

继承 Thread，重写 run()：

1
class Worker extends Thread {
2
    @Override
3
    public void run() {
4
        System.out.println("worker is running");
5
    }
6
}
7

8
// 在调用者的方法中
9
Worker worker = new Worker();
10
worker.start();

实现 Runnable，把任务对象传给 Thread：

1
class Task implements Runnable {
2
    @Override
3
    public void run() {
4
        System.out.println("task is running");
5
    }
6
}
7

8
// 在调用者的方法中
9
Thread worker = new Thread(new Task());
10
worker.start();

Runnable 是接口，要求提供 public void run()。它把“要执行的任务”放在任务对象中，任务类仍可继承其他类；实际线程由传入该对象的 Thread 创建。

start(), run(), and join()#

• start()：启动新线程，使它有机会执行 run()；具体何时获得 CPU 由调度决定。
• 直接调用 run()：按照普通方法调用，在当前线程上执行相应代码。
• join()：让调用者等待目标线程结束。调用者可能因中断而收到 InterruptedException。

同一个 Thread 对象只能成功启动一次；线程结束后不能再次调用它的 start() 来重新运行。

1
public class SumDemo {
2
    static class SumTask implements Runnable {
3
        private final int upper;
4
        long result = 0;
5

6
        SumTask(int upper) {
7
            this.upper = upper;
8
        }
9

10
        @Override
11
        public void run() {
12
            for (int i = 1; i <= upper; ++i)
13
                result += i;
14
        }
15
    }
16

17
    public static void main(String[] args)
18
            throws InterruptedException {
19
        SumTask task = new SumTask(5);
20
        Thread worker = new Thread(task);
21
        worker.start();
22
        worker.join();
23
        System.out.println(task.result);  // 15
24
    }
25
}

Java Thread States#

使用 new、runnable、blocked、dead 四种状态构成简化模型：

• 创建对象后处于 new；调用 start() 后进入 runnable。
• runnable 表示线程可执行，包含已运行或等待 CPU 的情况。
• 因等待事件暂时不能继续时，进入图中的广义 blocked；等待结束后回到 runnable。
• run() 执行结束后进入 dead。

Java 的 Thread.State 定义六种状态，阅读真实代码与调试输出时应使用下列含义：

Thread Interruption#

用 interrupt() 说明 Java 中的协作式停止：它可以设置目标线程的中断状态，目标在线程循环中检查并决定如何清理、退出。

1
while (!Thread.currentThread().isInterrupted()) {
2
    // 完成一段工作，并在合适位置响应停止请求
3
}

调用 interrupt() 不保证目标线程立即终止。 若线程正在 sleep()、wait() 或 join() 等可中断等待中，可能通过 InterruptedException 响应，中断状态也会被清除；程序需要按任务含义处理异常与退出逻辑。