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

分手后的思念是犯贱 2024-03-26 17:42 44阅读 0赞

#### 目录 ####

*   *  前言
     *  内核对进程和线程的表示
     *  创建进程的过程
     *  创建线程的过程
     *  创建进程和线程的异同
     *   *  揭秘 do\_fork 系统调用
         *  结论

### 前言 ###

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

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

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

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

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

### 内核对进程和线程的表示 ###

都用task\_struct表示

![在这里插入图片描述][5778dd9a70bd494695b542dc10b5c647.png]

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

--------------------

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

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

![在这里插入图片描述][6d726a3b2bc6498e8746cdc3fbdbd068.png]

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

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

--------------------

### 创建进程的过程 ###

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

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

![在这里插入图片描述][b0fd7d0e6d964d6691a4ea4694386602.png]

通过分析内核源码，创建进程时**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()系统调用源码放下下面线程的最终介绍，方便区分创建进程和创建线程本质的区别

### 创建线程的过程 ###

同样如上图:

![在这里插入图片描述][b0fd7d0e6d964d6691a4ea4694386602.png]

通过分析源码,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 出来**。

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

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

--------------------

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

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

![在这里插入图片描述][65b18833135b44be8e720f3f5f3b3e4e.png]

通过mm\_struct字段访问物理内存的过程:

![在这里插入图片描述][330546e2c402465cbe67f673ec947544.png]

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

![在这里插入图片描述][1bb8b29d28d4491b81eae8b7ccac096e.png]

通过mm\_struct字段访问物理内存的过程:

![在这里插入图片描述][8ce1a3beaee14038867f0bf2ab29e3a7.png]

#### 结论 ####

1.  **对于进程来讲**，地址空间 mm\_struct、挂载点 fs\_struct、打开文件列表 files\_struct 等**各种task\_struct中的核心字段都要是独立拥有的**，都需要去申请新的内存并初始化它们。（这也体现了，进程之间字段不共享，资源分配的基本单位）
2.  **对于线程来讲**，其地址空间 mm\_struct、目录信息 fs\_struct、打开文件列表 files\_struct 等**各种task\_struct中的核心字段都是和创建它的任务共享的**;（这也体现了线程和创建他的进程，字段等资源共享，但线程有唯一pid，是调度的基本单位）

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

[5778dd9a70bd494695b542dc10b5c647.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/9af6aeea65d74dd18046f889197089e2.png
[6d726a3b2bc6498e8746cdc3fbdbd068.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/5d137f071ea04558bd54c7d196a631d3.png
[Linux]: https://wtlcode.blog.csdn.net/article/details/128916439
[b0fd7d0e6d964d6691a4ea4694386602.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/1eaea7e858324427a84e96c2f833a6ee.png
[65b18833135b44be8e720f3f5f3b3e4e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/0380a8cfb66c41a1a9089504a8927c92.png
[330546e2c402465cbe67f673ec947544.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/eeb722c5e099440ab27274b2c8ad0c5b.png
[1bb8b29d28d4491b81eae8b7ccac096e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/9a5f125741de4d6eb08a55f75264a096.png
[8ce1a3beaee14038867f0bf2ab29e3a7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/0b4b2e8f98c841dbaad09babfe0ff964.png