内核角度谈谈Linux进程和线程

前言

昨天面试的时候，面试官问我了个平平淡淡的问题–>“聊聊Linux中进程和线程”;

相比大家不管是在考试还是面试中或多或少都遇到过这个问题，俗话说得好:

进程是资源分配的基本单位，线程是资源调度的基本单位！

这个你我都知道，但是这样解释感觉有点牵强和敷衍，记住八股不是背的，是要理解，这样面试才能有深度，配合上清晰的逻辑表达，凡可百战百胜！

在网上对进程和线程的讨论中，很多都是聚集在这二位有啥不同。但事实在 Linux 上，进程和线程的相同点要远远大于不同点。在 Linux 下的线程甚至都被称为了轻量级进程。(至于说轻量在哪儿，稍后我们最终结论就会浮现)

我今天就给大家从 Linux 内核实现的角度，给大家深度对比下进程和线程。

内核对进程和线程的表示

都用task_struct表示

对于线程来讲，所有的task_struct字段都是和进程一样的（本来就是一个结构体来表示的）。包括状态、pid、task 树关系、地址空间、文件系统信息、打开的文件信息等等字段，线程也都有。

---

对于进程来说，这个 pid 就是我们平时常说的进程 pid。

对于线程来说，我们假如一个进程下创建了多个线程出来。那么每个线程的 pid 都是不同的。但是我们一般又需要记录线程是属于哪个进程的。这时候，tgid 就派上用场了，通过 tgid 字段来表示自己所归属的进程 ID

这样内核通过 tgid 可以知道线程属于哪个进程。

这也就是我前面说的，进程和线程的相同点要远远大于不同点，本质上是同一个东西，都是一个 task_struct ！正因为进程线程如此之相像，所以在 Linux 下的线程还有另外一个名字，叫轻量级进程。(至于说轻量在哪儿，稍后我们最终结论就会浮现)

---

创建进程的过程

Linux下每个进程本质上是一个task_struct（PCB），这点可以参考我的这篇文章Linux虚拟地址空间

事实上，进程线程创建的时候，使用的函数看起来不一样。但实际在底层实现上，最终都是使用同一个函数来实现的:

通过分析内核源码，创建进程时fork 调用主要就是执行了 do_fork 函数。

注意：fork 函数调用 do_fork 的传的参数分别是SIGCHLD、0,0,NULL,NULL

//file:kernel/fork.c
SYSCALL_DEFINE0(fork)
{
    
    
 return do_fork(SIGCHLD, 0, 0, NULL, NULL);

do_fork() 函数又调用 copy_process 完成进程的创建。

//file:kernel/fork.c
long do_fork(...)
{
    
    
 //复制一个 task_struct 出来
 struct task_struct *p;
 p = copy_process(clone_flags, ...);
 ...
}

copy_process()系统调用源码放下下面线程的最终介绍，方便区分创建进程和创建线程本质的区别

创建线程的过程

同样如上图:

通过分析源码,lib库中的pthread_create创建线程会调用**clone()**系统调用,为其传入了一组 flag。

//file:nptl/sysdeps/pthread/createthread.c
static int
create_thread (struct pthread *pd, ...)
{
    
    
 int clone_flags = (CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGNAL
    | CLONE_SETTLS | CLONE_PARENT_SETTID
    | CLONE_CHILD_CLEARTID | CLONE_SYSVSEM
    | 0); //这个flag传入了下面的do_clone()
 
 int res = do_clone (pd, attr, clone_flags, ...);
 ...
}

do_clone()会执行一段汇编代码，进入clone系统调用:

//file:sysdeps/unix/sysv/linux/i386/clone.S
ENTRY (BP_SYM (__clone))
	...
	movl	$SYS_ify(clone),%eax
	...

紧接着查看系统调用clone()的实现，发现调用了do_fork()：

//file:kernel/fork.c
SYSCALL_DEFINE5(clone, ......)
{
    
    
 return do_fork(clone_flags, newsp, 0, parent_tidptr, child_tidptr);
}

验证了上图，还是执行到了内核中的do_fork() 函数,下面是do_fork()的源码:

//file:kernel/fork.c
long do_fork(unsigned long clone_flags, ...)
{
    
    
 //复制一个 task_struct 出来
 struct task_struct *p;
 p = copy_process(clone_flags, stack_start, stack_size,
    child_tidptr, NULL, trace);
 
 //子任务加入到就绪队列中去，等待调度器调度
 wake_up_new_task(p);
 ...
}

验证了上图，do_fork() 函数进一步执行了copy_process()系统调用，上源码:

//file:kernel/fork.c
static struct task_struct *copy_process(...)
{
    
    
 //4.1 复制进程 task_struct 结构体
 struct task_struct *p;
 p = dup_task_struct(current);
 ...
 
 //4.2 拷贝 files_struct
 retval = copy_files(clone_flags, p);
 
 //4.3 拷贝 fs_struct
 retval = copy_fs(clone_flags, p);
 
 //4.4 拷贝 mm_struct
 retval = copy_mm(clone_flags, p);
 
 //4.5 拷贝进程的命名空间 nsproxy
 retval = copy_namespaces(clone_flags, p);
 
 //4.6 申请 pid && 设置进程号
 pid = alloc_pid(p->nsproxy->pid_ns);
 p->pid = pid_nr(pid);
 p->tgid = p->pid;
 if (clone_flags & CLONE_THREAD)
  p->tgid = current->tgid;
 
 ......
}

可以看到，copy_process（）先copy了task_struct，然后紧接着有许多对task_struct中一些字段的拷贝函数，这些拷贝函数的处理规则取决于clone传入的参数clone_flags，这也是进程线程最本质的区别，下面进行总结！

---

创建进程和线程的异同

可见和创建进程时使用的 fork 系统调用相比，创建线程的 clone 系统调用几乎和 fork 差不多，也一样使用的是内核里的 do_fork 函数，最后走到 copy_process 来完整创建。

不过创建过程的区别是二者在调用 do_fork 时传入的 clone_flags 里的标记不一样！。

• 创建进程时的 flag：仅有一个 SIGCHLD
• 创建线程时的 flag：包括 CLONE_VM、CLONE_FS、CLONE_FILES、CLONE_SIGNAL、CLONE_SETTLS、CLONE_PARENT_SETTID、CLONE_CHILD_CLEARTID、CLONE_SYSVSEM。

关于线程多传入的这些 flag 的含义，我们选几个关键的做一个简单的介绍:

• CLONE_VM: 新 task 和父进程共享地址空间
• CLONE_FS：新 task 和父进程共享文件系统信息
• CLONE_FILES：新 task 和父进程共享文件描述符表

这些 flag 会对 task_struct 产生啥影响，我们接着看接下来的内容：

揭秘 do_fork 系统调用

前面我们看到，进程和线程创建都是调用内核中的 do_fork 函数来执行的。在 do_fork 的实现中，核心是一个 copy_process 函数，它以拷贝父进程（线程）的方式来生成一个新的 task_struct 出来。

//file:kernel/fork.c
long do_fork(unsigned long clone_flags, ...)
{
    
    
 //复制一个 task_struct 出来
 struct task_struct *p;
 p = copy_process(clone_flags, stack_start, stack_size,
    child_tidptr, NULL, trace);
 
 //子任务加入到就绪队列中去，等待调度器调度
 wake_up_new_task(p);
 ...
}

在创建完毕后，调用 wake_up_new_task 将新创建的任务添加到就绪队列中，等待调度器调度执行。这个代码很长，我对其进行了一定程度的精简：

//file:kernel/fork.c
static struct task_struct *copy_process(...)
{
    
    
 //4.1 复制进程 task_struct 结构体
 struct task_struct *p;
 p = dup_task_struct(current);
 ...
 
 //4.2 拷贝 files_struct
 retval = copy_files(clone_flags, p);
 
 //4.3 拷贝 fs_struct
 retval = copy_fs(clone_flags, p);
 
 //4.4 拷贝 mm_struct
 retval = copy_mm(clone_flags, p);
 
 //4.5 拷贝进程的命名空间 nsproxy
 retval = copy_namespaces(clone_flags, p);
 
 //4.6 申请 pid && 设置进程号
 pid = alloc_pid(p->nsproxy->pid_ns);
 p->pid = pid_nr(pid);
 p->tgid = p->pid;
 if (clone_flags & CLONE_THREAD)
  p->tgid = current->tgid;
 
 ......
}

可见，copy_process 先是复制了一个新的 task_struct 出来，然后调用 copy_xxx 系列的函数对 task_struct 中的各种核心字段进行拷贝处理，还申请了 新的pid 。

---

copy task_struct中各种字段时候的处理方式，就是区分进程和线程的重点：

• 创建进程中，因为没有传入task_struct中那些共享的字段，则他们都多copy了一份，有自己的内存空间（注意存在写时拷贝)

通过mm_struct字段访问物理内存的过程:

• 创建线程时,因为传入了task_struct中各种字段的共享标志位，则对应task_struct的各字段是共享的

通过mm_struct字段访问物理内存的过程:

结论

1. 对于进程来讲，地址空间 mm_struct、挂载点 fs_struct、打开文件列表 files_struct 等各种task_struct中的核心字段都要是独立拥有的，都需要去申请新的内存并初始化它们。（这也体现了，进程之间字段不共享，资源分配的基本单位）

2. 对于线程来讲，其地址空间 mm_struct、目录信息 fs_struct、打开文件列表 files_struct 等各种task_struct中的核心字段都是和创建它的任务共享的;（这也体现了线程和创建他的进程，字段等资源共享，但线程有唯一pid，是调度的基本单位）

总之，在 Linux 内核中并没有对线程做特殊处理，还是由 task_struct 来管理。从内核的角度看，用户态的线程本质上还是一个进程。只不过和普通进程比，稍微“轻量”了那么一些(轻量在：共享了各字段)