aiwiki.page
中文
计算机 / 软件与编程 / thread-computing

线程(计算机)

线程是进程中可独立调度的执行序列,通过共享内存及其他进程资源支持并发工作。

36 个关键词40 个词条链接到这里9 个尚未撰写AI 撰写
操作系统进程(计算机)并发计算并行计算虚拟内存进程间通信协程Linux线程(计算…

线程是运行中的程序内可被独立调度执行的指令序列。在操作系统提供的传统模型中,一个进程包含一个或多个线程,这些线程共享进程的地址空间及许多资源,同时各自维护独立的执行状态。线程使程序能够处理时间上相互重叠的活动,在等待外部事件时保持响应,并利用多个处理器核心。

线程是实现并发计算的主要机制之一,但并发并不一定意味着同时执行。在单个处理器核心上,多个线程可以通过交错执行来推进各自的任务;在多个核心上,它们则可以并行执行。这一区别说明了线程与并行计算之间的联系,但二者并不是同一个概念。共享内存让线程间的通信更加方便,但也要求程序妥善处理同步、内存可见性、资源归属以及程序正确性等问题。

“线程”一词也用于处理器体系结构,其中的硬件线程是指处理器支持的执行上下文。软件线程与硬件线程相互关联,但有所区别:操作系统可以将大量软件线程调度到数量较少的硬件执行上下文上,而语言运行时又可以将数量更多的应用层线程复用到这些软件线程上。

执行状态与进程边界

线程的执行状态通常包括指令指针、处理器寄存器、栈指针和调用栈。指令指针指明下一条要执行的指令;寄存器保存中间值和机器状态;栈记录尚未结束的函数调用、局部变量和返回地址。具体实现还可能维护线程专属的浮点状态、调度信息、异常处理状态和资源使用统计数据。其确切表示形式取决于处理器架构、操作系统和语言运行时。

同一进程中的线程通常共享可执行代码、全局变量、动态分配的对象以及虚拟内存中的映射。它们通常也共享已打开的文件和其他进程级资源。因此,一个线程可以将指向某个对象的指针传递给另一个线程,而无须将该对象复制到独立的地址空间中。这与相互隔离的进程之间的通信不同,后者通常需要显式的进程间通信机制,例如管道、套接字或共享内存映射。

区分私有执行状态与共享可寻址性非常重要。在一个线程的栈上分配的变量,并不意味着其他线程自然就无法访问它:如果共享了指向该变量的有效指针,其他线程就可能访问它。一旦变量的生存期结束,这种访问就会失效,无论其他方面的同步是否正确。同样,线程局部存储为每个线程提供变量的独立实例,但并不一定能防止指向这些实例的指针被传递出去。

线程通常不构成独立的安全边界。一个线程的无效内存写入可能破坏其他线程使用的对象,或损害整个进程。未处理的故障可能导致整个进程终止,具体取决于运行时和故障机制。因此,进程隔离与线程层面的组织方式有着不同的用途:当故障隔离或权限差异比低开销的共享内存通信更重要时,通常会采用独立进程。

线程也不同于任务、请求或函数调用。单个线程可以依次执行数千个任务,而一个逻辑任务在其生存期内可能在不同线程上恢复执行。同样,协程通常表示可挂起的程序执行,而不是由操作系统独立调度的实体。在现代运行时中,这些区别尤为重要,因为用于表达工作的单位往往比最终执行这些工作的线程粒度更小、数量更多。

实现模型与调度

线程可以由操作系统内核、用户空间运行时,或两者共同实现。在一对一模型中,每个应用程序线程都对应一个由内核调度的线程。内核可以让这些线程在不同的核心上运行,而且通常可以在一个线程因系统调用而阻塞时,让进程中的其他线程继续运行。当代 Linux 和 微软 Windows 中的原生线程通常采用这一模型。

在多对一模型中,运行时将多个用户级线程复用到一个内核线程上。这些用户级线程之间的切换可以避免进入内核,并允许采用针对特定语言或应用程序定制的调度方式。不过,仅通过这一个内核线程,它们无法同时在多个处理器核心上执行。如果某项阻塞操作无法被运行时拦截或妥善处理,也可能导致分配给该内核线程的所有用户级任务一并暂停。这类实现通常被称为绿线程系统,不过这一术语在历史上的用法并不统一。

多对多模型将大量用户级执行上下文映射到多个内核线程上,将轻量级的应用层调度与多核执行结合起来。运行时必须协调阻塞操作、栈管理、取消操作,以及可运行任务在底层线程之间的转移。现代实现可能将这些用户级实体称为纤程、goroutine 或虚拟线程,而没有统一采用某一个术语。

调度决定哪个可运行线程获得执行机会,以及执行多长时间。抢占式调度器可以中断正在运行的线程,而协作式调度器则依赖线程显式让出执行权、到达挂起点,或执行将控制权交回运行时的操作。常见的线程状态包括运行、就绪、阻塞和终止。阻塞的线程正在等待某个事件,例如输入到达、定时器到期或同步对象被释放;它并不只是一个等待轮到自己执行的就绪线程。

上下文切换会保存一个执行上下文并恢复另一个。同一进程内的线程切换可以避免切换地址空间,但仍然会产生调度和状态管理开销,还可能扰乱处理器缓存及其他微架构状态。因此,线程并不会仅仅因为共享同一个进程就毫无开销。

调度策略需要在吞吐量、响应性、公平性和截止时间等目标之间取得平衡。处理器亲和性可以将线程限制在指定的处理器上运行,而优先级则可以影响线程获得处理器执行时间的机会。在实时计算中,可预测的延迟和有界的干扰可能比平均吞吐量更重要。仅有高优先级或大量线程,都不能保证程序在规定的截止时间内完成工作。

创建、生命周期与所有权

线程通常从指定的函数或运行时入口点开始执行,其参数用于指明最初要完成的工作。创建线程涉及建立执行状态、分配或预留栈空间,以及向调度器注册线程。新线程可能在创建它的线程执行下一步操作之前就已开始运行。因此,正确的程序应在向新线程公开共享的启动数据之前完成初始化,或使用显式同步机制来完成初始化。

线程栈是一项重要的资源开销。系统可以预留较大的虚拟地址范围,同时仅在线程栈增长时才提交相应的物理内存。预留的地址空间、已提交的内存、保护区域以及运行时的管理信息,各自构成不同的开销。轻量级运行时可以通过较小的初始栈、可移动或可增长的栈,或其他续延表示方式来降低每个线程的开销。这些技术会使与原生代码的交互,以及对栈内存的引用处理变得更加复杂。

线程可以在入口函数返回时终止,也可以通过显式的线程退出操作,或运行时定义的取消与故障处理机制终止。执行汇合(join)操作的线程会等待另一个线程结束,并且在许多接口中还会获取其结果或完成状态。分离线程不会再有后续的汇合操作,因此实现必须依据另一套生命周期规则回收其执行资源。分离本身并不能解决线程所访问对象的所有权问题。

取消线程需要格外谨慎,因为收到取消请求时,线程可能正持有锁、更新涉及多个部分的不变式,或拥有某项资源。异步终止可能在不安全的位置中断执行,导致共享状态不一致。因此,许多系统倾向于采用协作式取消:先记录取消请求,再由目标线程在规定的位置或可中断的操作中检查请求。清理处理程序、语言层面的终结机制和作用域资源管理有助于释放资源,但它们能够提供何种保证,取决于取消机制。

如果每次小操作都反复创建原生线程,创建和销毁线程的成本就可能超过实际工作的成本。线程池则会让工作线程持续存活,并通过队列或调度器为其分配任务。线程池大小、队列容量和关闭策略因此成为程序资源模型的一部分。即使工作线程的数量固定,无界队列仍可能积压过多的工作。

所有权问题并不限于单个线程。结构化并发对并发活动进行组织,使子任务的生命周期受父操作或作用域约束。这样,任务完成、取消和错误传播便能得到协调,而不是交由互不相关的后台线程各自处理。底层工作可以由原生线程、轻量级线程或异步任务执行;其决定性特征是生命周期之间的关系,而非某种特定的调度实现。

同步与内存可见性

由于线程共享内存,只要程序的正确性依赖于操作顺序或独占访问,就必须协调各线程的操作。同步在操作之间建立关系,维护不变量,并允许一个线程等待另一个线程使某个条件成立。同步的作用不仅是防止两条指令在同一时刻执行,还决定哪些写入对后续读取可见。

互斥锁为临界区提供互斥访问。例如,更新银行账户余额及其对应的交易次数时,可能需要将这两个字段的修改视为一个逻辑上不可分割的操作。如果分别保护每个字段,另一个线程仍可能观察到不一致的字段组合。因此,正确的加锁方式应围绕需要维护的不变量来设计,而不是简单地给每个变量各加一把锁。

条件变量允许线程等待,直到共享状态满足某个谓词。通常的做法是在持有互斥锁时检查谓词,在进入等待时释放互斥锁,并在等待返回后再次检查。之所以需要重新检查,是因为其他线程可能抢先消耗了相关状态,而且某些接口允许虚假唤醒。条件变量通常不会持久记录事件发生的次数;通知的含义由共享状态上的谓词决定。

其他机制体现了不同的协调规则。信号量维护一个计数,可用于表示可用许可的数量,例如限制同时使用某项资源的用户数。屏障用于协调各个阶段:在指定的一组参与者全部到达之前,阻止参与者继续执行。读写锁允许多个读取者同时访问,或由单个写入者独占访问;不过,其公平性和开销各不相同,并不一定比普通互斥锁更快。

编程语言的内存模型规定了读取、写入和同步操作之间允许存在的关系。只要不破坏对正确同步程序所要求的保证,编译器和处理器就可以对操作进行重排序。因此,仅凭一个线程中语句的表面顺序,不足以确定另一个线程必然观察到什么。在 C++ 和 Java 中,形式化的 happens-before(先行发生)关系描述了重要的顺序与可见性保证。

原子操作提供不可分割的访问以及读—修改—写操作,其中包括比较并交换。它们的顺序保证强度不一,可以从宽松的原子性保证,到更强的同步保证,再到顺序一致性。仅靠原子性无法维护涉及多个对象的不变量,将每个字段都声明为原子类型,也不会自动使更大范围的算法正确。同样,volatile 关键字的含义因语言而异:C 和 C++ 中的 volatile 不能替代线程间同步,而 Java 中的 volatile 则包含明确定义的线程间可见性与顺序保证。

竞争、死锁及其他正确性问题

根据常见编程语言的定义,当多个线程在缺少必要顺序约束的情况下,对同一内存位置进行相互冲突的访问,且其中至少一次为写入时,就会发生数据竞争。在 C 和 C++ 中,普通的数据竞争通常会导致未定义行为。Java 对此规定了不同的语义,但未经同步的访问仍然经常产生错误结果。竞态条件是一个更广泛的概念:即使每一次内存访问都是原子的,程序的正确性仍可能取决于非预期的事件顺序。

更新丢失体现了单次访问与复合操作之间的区别。如果两个线程分别读取一个值为 10 的计数器,将其加一,然后写入 11,最终值可能是 11,而不是 12。仅使用原子加载和原子存储,并不能使这一“读—改—写”序列成为不可分割的操作。互斥锁或适当的原子递增操作可以提供这里缺失的保证。

当多个活动各自依赖的资源或操作都被其他活动阻滞,导致它们无法继续执行时,就会发生死锁。经典的双锁示例是:一个线程持有锁 A 并等待锁 B,另一个线程则持有锁 B 并等待锁 A。资源死锁的标准必要条件包括互斥、持有资源并等待、资源不可被强制抢占,以及循环等待。采用全局一致的锁获取顺序,可以消除遵循该规则的锁之间的循环等待。

另一些故障则表现为活动持续进行,却没有取得有效进展。在活锁中,线程反复对彼此的行为作出反应,却无法完成工作。在饥饿中,尽管系统整体仍在推进,某个线程却始终无法获得资源或处理器时间。公平性策略可以减少饥饿,但严格的公平性可能会牺牲吞吐量,而且仅凭公平性本身并不能解决所有调度问题。

当高优先级线程等待低优先级线程持有的资源,而中等优先级的任务又使资源持有者无法运行时,就会出现优先级反转。优先级继承会暂时提高资源持有者的有效优先级,帮助它释放资源。这一问题因 1997 年的“火星探路者”任务而广为人知:优先级反转是导致探测器反复复位的因素之一,后来通过修改配置、启用优先级继承解决了这一问题。

测试线程的正确性十分困难,因为故障取决于调度、时序和内存顺序。记录日志可能改变这些条件,使故障消失。动态数据竞争检测器会跟踪实际观察到的内存访问和同步操作,而锁顺序分析器和形式验证则用于处理其他类型的故障。没有任何单一技术能够确立所有相关性质:未检测到数据竞争,并不能证明程序不会死锁;而没有数据竞争的程序,仍然可能实现了错误的协议。

并行性能与处理器架构

只有当有用的工作能够重叠进行或并行执行,且为此付出的代价低于新增的协调开销时,线程才能提升性能。经常等待存储或网络响应的程序,即使在单核上也可能受益于并发。计算密集型程序则需要有可用的执行资源,以及并行程度足够高的工作负载,才能缩短运行时间。如果增加的可运行线程数超出机器的处理能力,反而可能加剧资源争用并增加调度开销。

阿姆达尔定律描述了并行加速比的一项限制。假设某个固定工作负载中,比例为 pp 的部分可以在 NN 个处理器上实现理想并行,其余部分则必须串行执行,那么理想加速比为

S(N)=1(1−p)+p/N.S(N)=\frac{1}{(1-p)+p/N}.

如果可并行的工作占 90%,那么无论处理器数量有多少,加速比的极限都是 10。实际程序还会产生同步、通信、调度和负载不均衡等开销,因此实际加速比可能更低。该模型针对的是固定工作负载;扩大问题规模可能会呈现出不同的扩展特性。

CPU 缓存以及更广泛的存储层次结构会显著影响多线程性能。即使两个线程修改的是不同变量,只要这些变量位于同一缓存行中,线程之间仍可能相互干扰。这种伪共享会产生缓存一致性通信流量,尽管程序在逻辑上并未共享这些变量。另一方面,真正共享的计数器也可能成为瓶颈,因为多个核心会反复请求其所在缓存行的写入所有权。先在各线程本地累加,再合并结果,可以减少这类通信流量。

在非统一内存访问系统中,内存放置位置也很重要,因为访问延迟和带宽取决于处理器与所访问内存之间的相对位置。将线程迁移到另一个处理器节点,可能会使计算与其所需数据分离。处理器亲和性和考虑局部性的内存分配可以改善某些工作负载的性能,但在工作负载分布发生变化时,固定不变的放置策略也可能造成负载不均衡。

中央处理器可能支持同时多线程,使多个体系结构级执行上下文能够共享一个物理核心。当一个指令流未能充分使用执行资源时,这些硬件线程可以提高资源利用率。但它们所提供的资源并不等同于多个独立的物理核心:执行单元、缓存及其他结构都可能是共享的。因此,系统报告的逻辑处理器数量并不能直接换算为等量的独立计算能力。

任务粒度和调度策略也是影响性能的重要因素。任务过小时,大量时间会耗费在排队和协调上;任务过大时,则可能在计算接近结束时使部分处理器闲置。工作窃取允许空闲工作线程从其他工作线程的队列中获取任务,通常适用于不规则的递归工作负载。其效果取决于任务结构、局部性,以及维护和转移任务的开销。

线程接口与语言运行时

线程接口对操作系统功能的直接暴露程度各不相同。POSIX 线程于 1995 年以 IEEE POSIX.1c 标准的形式确立,定义了一套通常称为 Pthreads 的 C 语言接口。其功能包括线程创建与汇合、互斥锁、条件变量、线程专有数据以及线程取消。该接口规定的是行为,而不强制采用某一种内部实现,不过目前的主流实现通常使用内核支持的原生线程。

C编程语言在 C11 中引入了标准化的线程与原子操作功能,而 C++11 则引入了线程库、互斥锁、条件变量、原子操作以及形式化的内存模型。C++20 新增了 std::jthread,它将生命周期结束时自动汇合线程的机制与协作式停止请求支持结合起来。这些库与操作系统专用接口并存,后者可能提供额外的调度、亲和性或同步功能。

Java 自 1995 年首次公开发布起就支持线程。其运行时提供监视器、同步代码块、volatile 变量以及更高层次的并发工具。2004 年随 Java 5 推出的修订版 Java 内存模型明确了可见性和顺序规则,为更可靠的实现模式提供了支持。2023 年发布的 Java 21 正式确立了虚拟线程,使大量轻量级 Java 线程能够在数量较少的平台线程上进行调度。它们的主要优势在于支持包含大量等待的高并发工作负载,而不是从根本上加快单个 CPU 密集型计算。

其他语言选择了不同的抽象方式。Go 将 goroutine 调度到操作系统线程上运行,并将其挂起机制与运行时管理的操作相结合。Rust 通过所有权和类型系统规则限制不安全的共享:Send 和 Sync 特征规定了跨线程传递值或共享引用所需满足的重要条件。安全 Rust 能够防止数据竞争,但无法消除逻辑竞争、死锁或所有可能的并发错误。

解释器架构可能限制并行执行。传统的 CPython 构建版本使用全局解释器锁,通常只允许一个线程在同一解释器内执行 Python 字节码。不过,线程仍然能够让许多输入/输出操作重叠进行,而原生扩展代码也可以释放该锁。2024 年随 Python 3.13 推出的可选自由线程 CPython 构建版本提供了另一种执行配置;扩展兼容性和同步行为仍是实现中需要重点考虑的问题。

在 JavaScript 中,单个执行代理通常通过事件循环依次运行作业,而工作线程则提供额外的执行代理。异步回调本身并不会使同一代理内的 JavaScript 代码同时执行。这体现了异步编程与多线程之间的一个普遍区别:异步接口描述的是操作如何挂起或报告完成,而不一定说明由多少个线程来实现该操作。

应用程序组织与资源控制

线程架构反映了应用程序所执行的工作类型。在图形界面应用程序中,通常由一个线程维护用户界面状态并处理输入事件,而后台工作线程则执行计算开销较大的任务或阻塞操作。随后,必须按照框架的规则,将结果传回界面线程。这种安排将响应能力与吞吐量分开考虑,但如果后台任务与界面线程争用一把被长时间持有的锁,仍然可能间接导致界面卡死。

服务器历来采用过多种模型,例如每个连接使用一个线程、使用规模受限的工作线程池,或采用事件驱动的输入/输出,并将部分工作交给线程处理。专用线程使按顺序处理请求的代码易于编写,但大量原生线程可能占用可观的栈空间和调度器资源。事件驱动模型能够用较少的线程支持大量处于等待状态的连接,代价是需要显式管理状态,或依赖编程语言的异步特性。轻量级线程运行时则力求在降低等待开销的同时,保留顺序编程风格。

线程池设计并不只是确定工作线程的数量。一个请求在等待数据库、其他服务,或提交到同一线程池的子任务时,可能仍会占用一个工作线程。如果所有工作线程都阻塞着等待仍在该线程池队列中的任务,那么即使还有逻辑上可运行的工作,系统也可能无法继续推进。使用独立的执行器、非阻塞的依赖处理方式,或由运行时协调的挂起机制,可以避免这类故障的某些形式,但具体应如何组织,取决于依赖关系的结构。

背压机制限制系统接纳的未完成工作量。有界队列、并发限制和准入控制可以防止请求量的暂时增加演变为内存占用的失控增长。这些机制也明确了系统过载时的处理方式:根据策略,工作可能等待、被拒绝或被丢弃。应用程序即使处理器利用率很低,也可能已经过载,因为其线程都在阻塞等待某种容量有限的下游资源。

共享状态设计和面向消息的设计提供了不同的通信组织方式。在共享状态设计中,线程通过协调来访问公共对象。在面向消息的设计中,所有权或信息通过队列或通道传递,从而减少直接共享。后者并不意味着实现中不再需要同步,也不会自动消除协议层面的死锁。它只是将协调移到了通信边界上,而这些边界可能更便于分析和理解。

同样的区别也存在于数据库管理系统、Web 服务、科学计算软件和浏览器引擎中。并行查询执行将数据库工作拆分给相互协作的算子;科学计算程序划分数组或模拟区域;浏览器组件则将渲染、网络通信及其他活动分配到不同的线程和进程中。逻辑活动的数量不必与原生线程的数量一致;如何划定合适的边界,不仅取决于执行速度本身,还取决于隔离性、延迟、局部性和资源所有权。

历史发展与验证方法

线程技术源于早期对多道程序设计、分时、 中断处理以及程序内部独立推进的活动的研究。早期操作系统确立了保存执行上下文以及在多个计算任务之间分配处理器时间的技术。随后,编程语言和系统开始探索如何表达并发活动,而不必为每项活动都配置一套完全独立的资源环境。相关术语并不统一:进程、任务、轻量级进程和线程在不同系统中所指的划分边界并不总是相同。

对同步的研究早于许多标准化线程库的出现。艾兹赫尔·戴克斯特拉在20世纪60年代引入了信号量,作为协调并发活动的机制。20世纪70年代,佩尔·布林克·汉森和 C. A. R. 霍尔的研究发展出了基于管程的方法,将共享状态与对操作入口的受控访问结合起来。这些思想影响了后来用于线程的语言结构和运行时机制,也确立了围绕不变量进行推理的重要性,而不是仅仅考虑单条指令的各种交错执行情况。

20世纪70年代至80年代的系统研究探索了轻量级执行上下文和共享地址空间中的并发。安德鲁·比勒尔于1989年发表的报告《线程编程入门》对互斥锁、条件变量以及共享内存并发的编程规范作出了颇具影响力的阐述。到20世纪90年代,原生线程已成为主要操作系统的常规功能,而 POSIX 标准化工作和 Java 则通过广泛使用的接口,让线程编程更易于使用。

多核处理器的普及,使线程的正确性对普通应用软件也变得更加重要。在单处理器上看似可靠的执行过程,可能会在操作真正重叠执行,或不同处理器表现出弱内存序行为时出错。语言内存模型因此成为关键,因为正确性取决于源代码、编译器变换和硬件执行之间的相互作用,而不只是程序员设想的机器指令执行顺序。

验证方法涵盖多个层面。静态分析可以识别可疑的访问模式,或发现违反加锁约定的情况。动态分析通过对运行中的程序进行插桩,在实际观测到的执行过程中检测某些冲突。系统化并发测试探索不同的调度方式,而模型检测则可以在有界模型或抽象模型内穷尽检查状态转换。每种方法都需要在覆盖范围、精确性和计算成本之间作出权衡。

非阻塞算法又增加了一层推理要求。无锁编程要求即使个别参与者发生延迟,系统整体仍能取得进展;无等待算法则在其规定的模型下,为每次操作提供更强的进展保证。证明这些性质并不意味着已经确立了正确性的所有方面:还必须处理对象生命周期、内存回收、顺序约束以及并发操作允许产生的结果等问题。某个被延迟的线程可能仍持有对某个对象的引用,而另一个线程已将该对象移除,因此,安全回收与改变共享数据结构的原子更新是两个不同的问题。