罗罗编程学习记录
本页内容 展开查看

01.1.1.1 进程与线程本质及 Linux 任务结构

所属:全栈开发面试题库 / 01 计算机基础与通用工程 / 01.1 操作系统 / 01.1.1 进程线程与调度

01.1.1.1-001 进程和线程的本质区别是什么?

一句话结论

进程是操作系统资源分配的最小单位,拥有独立虚拟地址空间与文件描述符表;线程是 CPU 调度的最小单位,同一进程内的线程共享堆、代码段、打开文件等进程资源,各自私有栈、寄存器与线程局部存储。

概念解释

  • 进程(process):执行中的程序实例,内核用 task_struct 描述,拥有独立页表、地址空间、信号处理表、文件描述符表。
  • 线程(thread):进程内的一条执行流,Linux 内核不区分进程与线程,统一称为任务(task),区别只在 clone 时共享了哪些资源。
  • 隔离性:进程之间地址空间隔离,一个进程崩溃通常不直接破坏其他进程;线程共享地址空间,一个线程野指针可能拖垮整个进程。

原理流程

  1. 创建进程:fork 复制父进程的任务结构与地址空间(写时复制),再 exec 加载新程序。
  2. 创建线程:clone 时传入 CLONE_VM 等标志,新任务共享父进程的地址空间、文件表与信号处置。
  3. 调度:内核调度器按任务(task_struct)选择下一个上 CPU 执行的执行流。

代码或图示

进程 P(独立页表 / 独立 fd 表 / 独立信号表)
├── 线程 T1:私有栈、寄存器、TLS;共享堆与代码段
├── 线程 T2:私有栈、寄存器、TLS;共享堆与代码段
└── 线程 T3:私有栈、寄存器、TLS;共享堆与代码段

常见误区

  • 把“线程是调度单位、进程是资源单位”理解成两套内核对象:Linux 内核里进程和线程都是 task_struct,共享资源多少不同而已。
  • 认为多线程一定比多进程快:线程切换省地址空间切换,但共享资源带来锁竞争;隔离性要求高时多进程更稳。

追问

  • 为什么线程切换比进程快?答:线程共享页表,切换时无需刷新地址空间与 TLB;进程切换要换页表基址,TLB 失效代价更高。
  • 多进程和多线程怎么选?答:隔离性、稳定性优先选多进程(如主从进程模型);频繁通信、共享内存数据优先线程池;高并发 IO 场景再叠加协程。

01.1.1.1-002 Linux 内核用什么数据结构描述进程和线程?task_struct 包含哪些关键信息?

一句话结论

Linux 内核用 task_struct(进程描述符)描述每个任务,它串联了调度信息、地址空间、打开文件、信号处理、进程关系、记账统计等全部上下文;进程与线程共用这一结构。

概念解释

  • task_struct 位于内核栈附近(task_struct 与内核栈在同一内存区域分配),是内核管理任务的核心对象。
  • 字段分组:调度类与优先级、状态、线程信息、内存描述符 mm_struct、文件描述符表 files_struct、信号处理 signal_struct、父子进程链表、PID/TGID、记账与资源限制。
  • 术语:任务(task)是内核视角的统称;用户视角的“进程”对应一个线程组(thread group),“线程”对应组内一个任务。

原理流程

  1. 任务创建时分配 task_struct 与内核栈。
  2. 各子系统把自己的上下文挂到描述符对应字段(内存、文件、信号、调度)。
  3. 调度器按 task_struct 中的调度字段选择任务;退出时逐级释放各子系统资源。

代码或图示

task_struct
├── 调度:state、prio、sched_class、vruntime、run_list
├── 身份:pid、tgid、parent、children、thread_group
├── 内存:mm_struct(页表、代码/堆/栈映射)
├── 文件:files_struct(fd 表)、fs_struct(当前目录/根)
├── 信号:signal_struct、sighand_struct、pending 队列
└── 记账:utime/stime、ru_maxrss、rlimit

常见误区

  • 以为 task_struct 里存着用户栈内容:用户栈在进程地址空间,描述符只保存指向它的信息;内核栈与寄存器现场在内核侧。
  • 以为一个进程只有一个 task_struct:多线程进程每个线程一个 task_struct,同属一个线程组。

追问

  • 如何在内核外查看这些信息?答:ps -o pid,tid,pcpu,stat,comm、top -H 看线程;/proc/<pid>/status、/proc/<pid>/task/<tid>/ 是描述符字段的用户态暴露。
  • mm_struct 对应什么?答:进程地址空间描述符,记录页表、各内存区 vm_area_struct 链表、代码/堆/栈/映射区位置。

01.1.1.1-003 进程虚拟地址空间由哪些部分组成?

一句话结论

现代 Linux 进程地址空间从低到高一般包含代码段、只读数据段、已初始化数据段、堆(向上增长)、内存映射区(共享库、mmap)、栈(向下增长),内核空间位于高位且用户态不可直接访问。

概念解释

  • 代码段(text):可执行指令,只读共享;只读数据段(rodata):常量。
  • 数据段(data):已初始化全局变量;BSS:未初始化全局变量,启动时清零。
  • 堆:动态分配内存(brk/mmap),向上增长;栈:函数调用帧,向下增长;映射区:动态链接库、mmap 文件映射与匿名映射。
  • 32 位与 64 位布局不同;64 位用户地址空间仅使用低位部分,高位是内核空间。具体布局随架构与内核版本变化,待确认项以本机 pmap 输出为准。

原理流程

  1. 程序加载:内核按 ELF 头映射代码段、数据段,清零 BSS。
  2. 运行期:malloc 小内存走 brk 扩堆,大内存走 mmap 映射区;函数调用压栈。
  3. 共享库通过映射区载入,多个进程可共享同一物理代码页。

代码或图示

高地址 ┌────────────────────┐ 内核空间(用户态不可访问)
       │ 栈(向下增长)      │
       │   ↓ 栈帧            │
       │ 映射区(向上增长)   │ 共享库 / mmap
       │   ↑ 堆              │
       │ 堆(向上增长)      │
       │ BSS / data / rodata │
低地址 └────────────────────┘ 代码段 text

常见误区

  • 以为堆和栈在地址空间里一定相邻:中间隔着映射区,布局由内核与链接器决定。
  • 以为全局变量都在数据段:未初始化全局变量在 BSS,不占可执行文件体积,运行时清零分配。

追问

  • 怎么查看某进程的内存布局?答:pmap -x <pid> 或读 /proc/<pid>/maps,按地址区间看权限、大小、映射文件。
  • 栈溢出会破坏哪里?答:栈增长越过栈边界触发缺页/栈保护,覆盖到相邻内存时属于内存越界,严重时段错误。

01.1.1.1-004 线程共享进程的哪些资源,各自私有什么?

一句话结论

同一进程内的线程共享代码段、数据段、堆、打开的文件描述符表、信号处置、当前工作目录与用户/组身份;每个线程私有执行栈、寄存器现场、线程局部存储、线程 ID 与调度优先级(可独立设置)。

概念解释

  • 共享的是“进程资源”:地址空间内的全局变量与堆、open 返回的 fd、信号处理函数、当前目录。
  • 私有的是“执行上下文”:栈帧与局部变量、PC/寄存器、TLS、errno(线程局部)、信号掩码可独立设置。
  • 风险:共享堆意味着并发访问必须同步;一个线程 close 了共享 fd,其他线程再使用就会出错。

原理流程

  1. 线程创建时 clone 携带 CLONE_VM(共享地址空间)、CLONE_FILES(共享 fd 表)等标志。
  2. 各线程获得独立内核栈与用户栈,调度时保存/恢复私有现场。
  3. 访问共享变量时通过内存可见性与锁机制保证正确性。

代码或图示

资源 线程间是否共享 说明
代码段、全局变量、堆 共享 并发读写需同步
文件描述符表 共享 同一 fd 指向同一打开文件
信号处置、当前目录、UID/GID 共享 属于进程级属性
栈、局部变量、寄存器、TLS 私有 调度切换时保存恢复
线程 ID、信号掩码、调度优先级 私有 可独立调整

常见误区

  • 以为局部变量每个线程都独立初始化一份却仍在堆上:局部变量在栈上,私有;静态局部变量在数据段,被所有线程共享。
  • 以为线程关闭 fd 只影响自己:fd 表是进程级共享,一个线程 close 后其他线程持有的该 fd 立即失效。

追问

  • 一个线程收到 SIGSEGV 后果是什么?答:信号默认处置作用于整个进程,进程终止;除非信号被阻塞并定向到该线程处理。
  • 多线程下 errno 为什么不会互相覆盖?答:errno 是线程局部存储,每个线程有自己的副本。

01.1.1.1-005 PID、TID、TGID 有什么区别?如何用命令观察?

一句话结论

PID 是进程 ID(线程组 ID,TGID),TID 是线程 ID;单线程进程的 PID 与 TID 相同,多线程进程中主线程 TID 等于 PID,其余线程 TID 不同但 TGID 都等于进程 PID。

概念解释

  • 内核视角:每个任务有 pid(TID);task_struct.tgid 是线程组 ID。
  • 用户接口:getpid() 返回 TGID(用户理解的进程号),gettid() 返回当前任务的 TID;ps 默认按线程组聚合,ps -L 或 top -H 显示线程级 LWP。
  • /proc/<pid>/task/ 下每个子目录是一个线程,目录名即 TID。

原理流程

  1. 进程创建:fork 后新任务 TGID 等于自身 PID。
  2. 线程创建:新任务 TGID 设为创建者的 TGID,自身 TID 独立。
  3. 观察:ps -eLf 列出 PID(TGID)、LWP(TID)、线程数;ls /proc/<pid>/task 核对线程数。

代码或图示

进程 PID=1000(TGID=1000)
├── 线程 TID=1000(主线程,TID == PID)
├── 线程 TID=1001
└── 线程 TID=1002

命令:ps -L -p 1000   # 列 PID、LWP、NLWP、PSR、COMM

常见误区

  • 把 ps 看到的数字都当线程号:默认 ps 显示的是线程组 PID,线程号要看 LWP 列。
  • 以为容器里看到的 PID 就是宿主机 PID:PID 有命名空间隔离,容器内 1 号进程在宿主机上是另一个 PID。

追问

  • 如何在代码里拿当前线程号?答:glibc 可调用 gettid()(或 syscall(SYS_gettid));Java 用 Thread.getId() 拿到的是 Java 线程 ID,不等于内核 TID。
  • 线程组在信号投递上有什么意义?答:发给进程(TGID)的信号由组内任意线程接收;发给特定 TID 的信号定向到该线程。

01.1.1.1-006 fork、exec、vfork 分别做什么?写时复制怎么工作?

一句话结论

fork 创建子进程并复制父进程上下文,exec 用新程序映像替换当前进程地址空间,vfork 早期用于避免复制页表、父子共享内存且子先运行;写时复制(COW)让 fork 后父子共享物理页,只有写入时才复制。

概念解释

  • fork:返回两次——父进程返回子进程 PID,子进程返回 0;失败返回 -1。
  • exec 一族:execve 加载 ELF,清空地址空间映射,建立新代码/数据段,PID 不变。
  • COW:fork 时不立即复制物理页,页表项标记只读并共享;任一方写入触发缺页,内核分配新页复制内容后再写。
  • vfork:子进程在父进程地址空间运行且阻塞父进程,直到 exec/退出;现代 fork 配合 COW 已足够轻量,vfork 场景很少。

原理流程

  1. fork:复制 task_struct、页表,物理页置 COW 只读。
  2. 子进程执行 exec:释放旧映射,加载新程序。
  3. 期间若子进程写入内存:COW 缺页 → 分配私有页 → 复制 → 恢复写权限。

代码或图示

fork:父 ──复制描述符/页表(页共享、只读)──> 子
  写入触发 COW 缺页:分配新物理页 → 复制内容 → 解除共享
exec:清空地址空间 → 映射新 ELF → 从入口点执行(PID 不变)

常见误区

  • 以为 fork 会把父进程全部内存逐页复制:COW 下只读页共享,未写入的页不复制。
  • 以为 exec 创建新进程:PID 不变,只是替换了程序映像。

追问

  • fork 后子进程继承哪些文件状态?答:打开的 fd 表副本,文件偏移量共享(同一打开文件描述);关闭执行时可设 FD_CLOEXEC 在 exec 时关闭。
  • 为什么多线程程序 fork 后容易出问题?答:只复制调用线程,其他线程消失;持有的锁可能处于未释放状态,子进程内再加锁易死锁,应尽快 exec。

01.1.1.1-007 进程有哪些生命周期状态?

一句话结论

Linux 任务常见状态:运行(R)、可中断睡眠(S)、不可中断睡眠(D)、停止(T)、僵尸(Z);ps 的 STAT 列还会附加次要标志位。

概念解释

  • R(Running/Runnable):在运行队列中或正在 CPU 上执行。
  • S(Interruptible Sleep):等待事件(如数据、锁),可被信号唤醒,最常见的空闲状态。
  • D(Uninterruptible Sleep):等待内核 IO 完成,不响应信号;长时间 D 状态通常要查磁盘/网络/驱动。
  • T(Stopped):被作业控制信号暂停(SIGSTOP),或被调试器跟踪。
  • Z(Zombie):已退出但父进程尚未回收描述符,残留 task_struct。

原理流程

  1. 任务就绪进入 R 队列,被调度上 CPU。
  2. 等待资源/事件进入 S 或 D;事件到达被唤醒回 R。
  3. 任务退出变为 Z,父进程 wait 回收后描述符释放。

代码或图示

R ──等待事件──> S/D ──事件到达──> R
R ──退出──> Z ──父进程 wait 回收──> 销毁
T:被 SIGSTOP 暂停,SIGCONT 恢复

常见误区

  • 看到大量 S 状态就判定异常:服务进程等待 IO/网络时处于 S 是正常空闲。
  • 以为 D 状态能被 kill -9 杀掉:D 状态不响应信号,需等内核 IO 返回;强杀可能挂在驱动层。

追问

  • 怎么区分 S 和 D?答:ps -o pid,stat,wchan:24,comm 看状态与等待通道;top 的 D 行配合 vmstat/iostat 判断是否 IO 阻塞。
  • 僵尸进程多了有什么危害?答:残留 task_struct 占 PID 与少量内核内存;少量无碍,大量堆积会耗尽 PID 或表明父进程回收逻辑有缺陷。

01.1.1.1-008 僵尸进程和孤儿进程怎么产生?怎么处理?

一句话结论

僵尸进程是子进程已退出但父进程未 wait 回收;孤儿进程是父进程先退出、子进程被 init(systemd 容器内为 1 号进程)接管。僵尸要靠父进程回收或退出,孤儿由 init 自动回收,通常无需干预。

概念解释

  • 僵尸(zombie):退出后内核保留退出码与资源统计,等待父进程读取;ps 显示 Z。
  • 孤儿(orphan):父进程退出后,子进程被祖先链上的 init 进程收养,退出时由 init 回收。
  • 处理僵尸:让父进程正确 wait/waitpid 或注册 SIGCHLD 处理函数;父进程无法修复时可结束父进程,让其子进程被 init 收养回收。

原理流程

  1. 子进程退出 → 发 SIGCHLD 给父进程 → 进入 Z。
  2. 父进程调用 wait 读取退出状态 → 描述符释放。
  3. 父进程先死 → 子进程被 init 收养 → 退出后由 init 回收。

代码或图示

子退出 ──> SIGCHLD ──> 父未 wait ──> 僵尸 Z
父先退出 ──> 子被 init(1) 收养 ──> 子退出由 init 回收

常见误区

  • 用 kill -9 杀僵尸:僵尸已死,信号无效;必须回收它的父进程或让父进程 wait。
  • 把孤儿当故障:孤儿只是被 init 收养,行为正常,不残留描述符。

追问

  • 服务端 fork 子进程怎么避免僵尸堆积?答:注册 SIGCHLD 处理器循环 waitpid(-1, ..., WNOHANG) 回收;或双 fork 让孙进程被 init 收养。
  • SIGCHLD 处理器里要注意什么?答:信号可能合并丢失,处理器内应循环非阻塞 waitpid 直到没有子进程可回收。

01.1.1.1-009 Linux 线程是怎么实现的?clone 传了哪些关键标志?

一句话结论

Linux 线程通过 clone 系统调用创建,传入 CLONE_VM、CLONE_FILES、CLONE_FS、CLONE_SIGHAND、CLONE_THREAD 等标志让新任务共享进程资源;不传这些标志就是传统 fork。

概念解释

  • CLONE_VM:共享地址空间;CLONE_FILES:共享文件描述符表;CLONE_FS:共享当前目录/根/umask;CLONE_SIGHAND:共享信号处置;CLONE_THREAD:归入同一线程组。
  • 标准库线程库(NPTL)封装 clone,完成栈分配、TLS 初始化与启动例程。
  • 进程与线程在内核都是任务,差异完全由 clone 标志决定。

原理流程

  1. 线程库分配用户栈与 TLS。
  2. 调用 clone 携带共享标志创建新 task_struct。
  3. 新任务从启动例程开始执行,与创建者并发运行。

代码或图示

fork  ≈ clone(CLONE_VFORK 语义外的少量标志):独立 mm、files、signal
pthread_create ≈ clone(
  CLONE_VM | CLONE_FILES | CLONE_FS | CLONE_SIGHAND | CLONE_THREAD | CLONE_SETTLS ...)

常见误区

  • 以为内核有专门的“线程对象”:内核只有任务对象,共享标志组合出线程语义。
  • 以为共享 fd 表是自动行为:CLONE_FILES 缺失时子任务会获得独立 fd 表副本。

追问

  • 怎么跟踪线程创建的系统调用?答:strace -f -e trace=clone,clone3,fork <程序>,-f 跟随子进程/线程;可看到每次 clone 的标志参数。
  • clone3 与老 clone 区别?答:clone3 用结构传参,支持更多隔离与退出通知特性;具体可用标志随内核版本变化,待确认以本机 man clone3 为准。

01.1.1.1-010 什么是 1:1、N:1、M:N 线程模型?

一句话结论

1:1 模型每个用户线程对应一个内核线程(Linux NPTL),调度由内核负责;N:1 模型所有用户线程映射到单个内核线程,用户态调度,阻塞会拖垮整体;M:N 模型在用户线程与内核线程间多路复用,兼顾轻量与阻塞调度。

概念解释

  • 1:1:线程切换要进内核,但阻塞语义简单;Java 平台线程、Go 早期模型之外的多数运行时采用。
  • N:1:协程库在用户态调度,切换快;任一阻塞系统调用会卡住唯一内核线程,需要非阻塞 IO 配合。
  • M:N:用户协程多路复用到底层内核线程,阻塞时把其他协程迁移走;Go GMP、Java 虚拟线程、Kotlin 协程运行时属于这一类思路。

原理流程

  1. 1:1:用户线程 ↔ 内核线程一一绑定,内核调度。
  2. N:1:用户调度器在单线程内轮转协程。
  3. M:N:调度器维护用户任务与内核载体的映射,阻塞/让出时迁移任务。

代码或图示

1:1:  U1─K1  U2─K2  U3─K3
N:1:  U1 U2 U3 ──> K1
M:N:  U1 U2 U3 U4 ⇄ K1 K2

常见误区

  • 把协程等同于 N:1 模型:现代协程运行时多为 M:N 或结合事件循环;纯 N:1 只能配合非阻塞 IO。
  • 以为 1:1 模型无法做高并发:线程池 + 非阻塞 IO 可以支撑高并发,只是单栈内存与切换成本高于协程。

追问

  • M:N 调度最难处理什么?答:阻塞系统调用与栈迁移,需要载体线程让出、任务换栈或绑定载体;运行时内部实现复杂。
  • 1:1 模型的阻塞代价是什么?答:一个线程阻塞就占住一个内核线程,高并发阻塞场景线程数膨胀,需配合非阻塞 IO。

01.1.1.1-011 进程组、会话、控制终端是什么关系?

一句话结论

进程组(PGID)是一组相关进程的集合,作业控制以进程组为单位发信号;会话(SID)包含多个进程组,同一会话绑定一个控制终端;终端关闭会向会话前台进程组发送挂起信号。

概念解释

  • 进程组:每个进程有 PGID,组长进程 PID 等于 PGID;kill -- -PGID 向整组发信号。
  • 会话:setsid 创建新会话并脱离控制终端;登录 Shell 是会话首领。
  • 前台/后台作业:前台进程组占有终端输入输出,后台作业被终端信号阻断写入。

原理流程

  1. Shell 启动作业时把进程归入同一进程组。
  2. 终端 Ctrl+C 产生 SIGINT 发给前台进程组;Ctrl+Z 产生 SIGTSTP。
  3. 守护进程 setsid 新建会话脱离终端,终端关闭不再影响它。

代码或图示

会话 SID=1000(控制终端 tty1)
├── 前台进程组 PGID=1100:shell 与前台命令
└── 后台进程组 PGID=1200:后台作业
命令:ps -o pid,pgid,sid,tty,comm

常见误区

  • 以为 nohup 就是新建会话:nohup 只忽略挂断信号并重定向,进程仍在原会话;setsid 才真正脱离终端与会话。
  • 后台进程输出到终端不报错是正常的:终端权限被作业控制管理,写后台作业会收到 SIGTTOU(视配置)。

追问

  • 怎么让服务脱离终端长期运行?答:setsid 新建会话、重定向 stdin/stdout/stderr,或由 systemd/容器托管;nohup cmd & 是常见兜底但不等于完全脱离。
  • 终端断开为什么有些进程会被杀?答:会话收到挂断(SIGHUP),默认处置终止前台/关联进程;nohup 忽略该信号。

01.1.1.1-012 线程栈大小在哪里配置?默认多大?栈里放什么?

一句话结论

NPTL 线程栈默认大小通常为 8 MiB(具体以 ulimit -s 与线程库编译/运行配置为准,待确认),可在 pthread_attr_setstacksize 创建时调整;栈保存函数帧、返回地址、局部变量与参数。

概念解释

  • 主线程栈大小由 Shell 资源限制决定;工作线程栈由线程库默认值分配,可逐线程设置。
  • 栈从高地址向低地址增长,超出栈边界触发栈扩展或缺页;栈不自动扩容到无限大。
  • 深递归、大局部数组会快速耗尽栈;栈上大对象应改为堆分配。

原理流程

  1. 创建线程时按属性预留栈区域(含警戒页)。
  2. 函数调用压栈帧,返回时弹栈。
  3. 栈指针越过警戒页触发缺页/栈溢出错误。

代码或图示

查看:ulimit -s                      # 主线程栈软限制(KB)
代码:pthread_attr_t attr;
      pthread_attr_setstacksize(&attr, 256*1024);
      pthread_create(&tid, &attr, fn, arg);

常见误区

  • 以为线程栈可以像堆一样自动长到很大:栈大小创建时确定,越过边界即报错。
  • 在栈上放大数组:局部大数组直接占栈,高并发线程下栈内存总量 = 线程数 × 栈大小,容易耗尽内存。

追问

  • 高并发下线程栈内存怎么估算?答:总栈内存 ≈ 线程数 × 单栈大小;例如 1000 线程 × 8 MiB ≈ 8 GiB,这也是 C10K 场景转向协程/非阻塞的原因之一。
  • 栈溢出错误在原生程序里表现是什么?答:通常段错误(SIGSEGV);Java 平台线程抛 StackOverflowError。

01.1.1.1-013 线程局部存储(TLS)是什么?

一句话结论

线程局部存储是每个线程私有一份的变量存储机制,编译器/运行时为每个线程独立分配副本,常用于 errno、线程 ID、上下文对象,避免共享带来的竞争。

概念解释

  • 声明方式:C11 _Thread_local、GCC __thread、pthread key(pthread_key_create);Java ThreadLocal 是运行时层的 TLS。
  • 生命周期:随线程创建分配、随线程销毁回收;线程池场景复用线程时要主动清理,避免脏数据串用。
  • 内核侧:task_struct 指向 TLS 区域,fs/gs 段寄存器定位(架构相关,细节待确认)。

原理流程

  1. 线程创建时为 TLS 变量分配独立副本。
  2. 线程访问变量时经段寄存器/运行时表定位到自己的副本。
  3. 线程退出时回收 TLS 区域。

代码或图示

线程 1 ── TLS 副本 A
线程 2 ── TLS 副本 B
代码引用同一个 __thread 变量,访问到各自副本

常见误区

  • 把 ThreadLocal 当全局缓存:线程池复用时上一任务残留的 value 会被下一任务读到,用完必须 remove。
  • 以为 TLS 变量在线程间可见:不可见,这正是它私有隔离的目的。

追问

  • 协程运行时 TLS 有什么坑?答:协程多路复用在线程上,线程级 TLS 不随协程切换保存/恢复;需要运行时提供协程局部上下文(如 Go 的 goroutine-local 需自行透传)。
  • pthread_key 析构函数何时调用?答:线程退出时对非 NULL key 调用析构回调,可用于释放绑定资源。

01.1.1.1-014 用户线程和内核线程有什么区别?

一句话结论

内核线程由内核创建与调度,没有用户地址空间(mm 为空),负责后台任务如 kswapd、kworker、 migration 线程;用户线程运行在进程地址空间,执行业务代码。

概念解释

  • 内核线程:kthread 启动,上下文只含内核栈,不访问用户内存,ps 名称带方括号如 [kworker/0:1]。
  • 用户线程:属于某个进程,有用户栈与地址空间。
  • 观察:ps -eLf 中内核线程 Comm 以 [ ] 包裹;/proc/<pid>/status 的 Vm* 字段为空。

原理流程

  1. 内核在初始化或需要时创建内核线程并加入调度。
  2. 内核线程执行内核函数,处理回收、IO 回填、迁移等后台工作。
  3. 用户线程通过系统调用进入内核时短暂借用内核栈执行内核逻辑。

代码或图示

内核线程:[kworker/0:1] [kswapd0] [migration/0]  —— 无用户 mm
用户线程:java/node/go 进程下各工作线程      —— 有独立 mm

常见误区

  • 看到 kworker 占用 CPU 就当成业务进程异常:它是内核工作线程,通常对应磁盘/网络/文件系统请求,应回溯是哪些系统调用触发。
  • 以为内核线程也会出现在用户态 top 的用户 CPU 列:内核线程消耗计入内核态(system)时间。

追问

  • 怎么定位某个 kworker 在做什么?答:cat /proc/<tid>/stack 看内核栈(需权限),配合 perf top/strace 回溯触发它的系统调用与文件路径。
  • 中断处理与内核线程关系?答:硬中断在上半段快速执行,耗时工作延后到软中断/内核线程下半段处理。

01.1.1.1-015 守护进程怎么创建?nohup 和 setsid 有什么区别?

一句话结论

守护进程是脱离控制终端、在后台长期运行的进程,标准步骤:fork 后父退出 → setsid 新建会话 → 再次 fork 防止重新打开终端 → 切工作目录、重定向标准流;nohup 只忽略 SIGHUP 并重定向,不新建会话。

概念解释

  • setsid:调用者成为新会话首领,无控制终端;会话首领重新打开终端需要显式操作,二次 fork 后进程不再是会话首领,避免拿回终端。
  • nohup cmd &:忽略挂断信号,输出追加到 nohup.out,进程仍属于原会话与进程组。
  • 生产实践:后台服务优先由 systemd、容器或进程管理器托管,不依赖手工 nohup。

原理流程

  1. 第一次 fork,父进程退出,子进程被 init 收养。
  2. 子进程 setsid 脱离终端与会话。
  3. 第二次 fork,切换目录、关闭/重定向标准流,进入后台服务循环。

代码或图示

fork → 父退出 → setsid → fork → 子进程:脱离终端、重定向 0/1/2
nohup:忽略 SIGHUP + 输出 nohup.out;不脱离原会话/进程组

常见误区

  • 以为 nohup 启动的进程断网也一定存活:它防的是挂断信号;机器重启、日志写满、进程崩溃仍会终止。
  • 以为 setsid 后标准流已经关闭:通常还需显式重定向到 /dev/null 或日志文件。

追问

  • systemd 托管服务和手写守护进程比优势在哪?答:自动重启、日志归集、资源限制、依赖排序、信号管理统一处理,不需要应用自己实现 daemon 化。
  • 容器里 1 号进程为什么要正确回收子进程?答:容器内 init 默认不做 wait,子进程容易变僵尸;应用需实现回收或用轻量 init。

01.1.1.1-016 如何用命令观察进程与线程?ps、top、pstree 各看什么?

一句话结论

ps 做静态快照选字段查看,top/htop 实时观察 CPU/内存趋势,pstree 看进程父子与线程层级;线程视角用 ps -L、top -H。

概念解释

  • ps -ef / ps aux:全量进程快照;ps -L -e 展开线程;-o 自选字段如 pid,ppid,pgid,stat,pcpu,pmem,rss,comm。
  • top:按 CPU 排序实时刷新,H 键切换线程视图;P 按 CPU、M 按内存排序。
  • pstree -p:树形展示父子关系与 PID;/proc/<pid>/task 是线程权威清单。

原理流程

  1. 定位进程:ps -ef | grep <关键词> 或 pgrep -af <名称>。
  2. 展开线程:ps -L -p <pid> 或 top -H -p <pid>。
  3. 核对层级:pstree -p <pid>,并对照 /proc/<pid>/task/ 数量。

代码或图示

ps -eo pid,ppid,pgid,stat,pcpu,pmem,rss,comm --sort=-pcpu
ps -L -p <pid>            # 列 LWP、NLWP、PSR(所在 CPU)
top -H -p <pid>           # 线程实时视图
pstree -p <pid>           # 父子/线程树

常见误区

  • 用 grep 结果判断进程数:管道可能把 grep 自身计入;用 pgrep 或排除自身更稳妥。
  • 只看 %CPU 不看状态:S 状态进程即使累计 CPU 偏高也可能是历史占用,需结合实时 top。

追问

  • RSS 和 VSZ 分别代表什么?答:RSS 是驻留物理内存(不含换出/共享库折算口径随工具不同),VSZ 是虚拟地址空间大小;内存趋势看 RSS 更有意义。
  • 怎么看进程在哪个 CPU 上跑?答:ps -o psr 或 top 的 P 列;taskset -p <pid> 查看/设置亲和性。

01.1.1.1-017 进程能打开的文件数、内存等资源限制怎么看?ulimit 与 cgroup 有什么区别?

一句话结论

ulimit 是 Shell 进程级软/硬资源限制(fd 数、栈大小、核心转储等),通过 rlimit 继承给子进程;cgroup 是内核按组统计与限额的机制(内存、CPU、PID 数等),容器限额依赖 cgroup。

概念解释

  • 软限制:当前生效值,可提高到硬限制;硬限制:普通用户不可越界。
  • 常见项:nofile(打开文件描述符上限)、stack、core、nproc(线程/进程数口径随系统)。
  • 查看:ulimit -a;进程视角读 /proc/<pid>/limits。
  • cgroup:按层级归集任务,统计并限制内存、CPU、IO、PID 等;/sys/fs/cgroup/ 下可见限额与当前用量。

原理流程

  1. Shell 启动时设定 rlimit,子进程继承。
  2. 进程打开 fd 超过 nofile 返回 EMFILE;线程/进程数超限返回 EAGAIN。
  3. 容器运行时通过 cgroup 写入内存/CPU 上限,内核按组执行回收与阻断。

代码或图示

ulimit -n                       # 当前 nofile 软限制
cat /proc/<pid>/limits          # 进程继承的全部 rlimit
cat /sys/fs/cgroup/memory.max  # cgroup v2 内存上限(示例路径,随版本)

常见误区

  • 以为改了 /etc/security/limits.conf 对已有会话生效:新登录会话才读取;运行中进程限制需重载服务。
  • 把 ulimit 和 cgroup 限额混为一谈:前者是进程 rlimit,后者是分组内核限额;容器内看到的可用内存以 cgroup 为准,不是整机。

追问

  • 服务报 “Too many open files” 怎么排查?答:先 lsof -p <pid> | wc -l 看 fd 类型与泄漏,再核对 /proc/<pid>/limits 的 nofile;fd 泄漏修代码,限额不足调配置并重载。
  • 容器内 Java 堆为什么不能按整机内存设?答:cgroup 限制了组内可用内存,堆+栈+元空间+直接内存不能超过上限;应识别 cgroup 限额而非读整机容量。

01.1.1.1-018 进程崩溃常见原因怎么定位?信号、core dump 与 strace 怎么配合?

一句话结论

崩溃先看退出信号与核心转储:dmesg/日志确认段错误等信号,开启 core dump 后用调试器分析崩溃点;strace 跟踪系统调用与信号,perf/性能计数器定位 CPU 与锁问题。

概念解释

  • 常见崩溃:空指针/野指针解引用(SIGSEGV)、栈溢出、断言失败、非法指令、主动 abort(SIGABRT)、内存越界覆盖。
  • 信号:同步陷阱(如段错误)由异常触发;异步信号由外部或另一进程发送。
  • core dump:进程崩溃时内存与寄存器快照,需 ulimit -c 开启并配置 core_pattern;调试器读取快照回溯栈、检查变量。

原理流程

  1. 收集现象:退出码、dmesg 中 segfault/killed 记录、应用日志。
  2. 跟踪复现:strace -f -tt -o trace.log <程序> 看最后系统调用与信号;ltrace 跟踪库调用(按需)。
  3. 分析快照:core 文件用 gdb <可执行> <core>,bt 回溯栈、info registers 看寄存器。

代码或图示

ulimit -c unlimited            # 当前会话允许 core
cat /proc/sys/kernel/core_pattern
strace -f -tt -e trace=all -o app.trace ./app
gdb ./app core.<pid>  →  bt  /  info locals  /  frame <n>

常见误区

  • 只看应用日志就下结论:原生崩溃常发生在库/驱动层,日志可能没有栈;core 快照是直接证据。
  • 线上环境直接开全量 core:大进程 core 文件可能巨大,应配置压缩/轮转与采样,避免磁盘写满。

追问

  • 怎么区分崩溃是内存越界还是外部信号杀死?答:段错误/非法指令是自身触发的同步异常;SIGKILL、SIGTERM 来自外部(OOM、发布、运维脚本),查 dmesg 的 OOM 记录与编排系统日志。
  • OOM killer 怎么识别?答:dmesg 中 Out of memory 与 Killed process 记录;cgroup v2 下查看内存事件计数,核对进程内存峰值与限额。