服务器开发26:Linux中线程和进程的联系与区别(游戏后端请和游戏思考10一起食用)


如是游戏工作者,请和 游戏思考10:游戏服务器的进程和线程简单谈谈一起食用

一、线程创建方法(以redis举例)

在 Redis 6.0 以上的版本里,也开始支持使用多线程来提供核心服务,我们就以它为例。在 Redis 主线程启动以后,会调用 initThreadedIO 函数来创建多个 io 线程。

  • 主线程
//file:src/networking.c
void initThreadedIO(void) {
 //开始 io 线程的创建
 for (int i = 0; i < server.io_threads_num; i++) {
  pthread_t tid;
  pthread_create(&tid,NULL,IOThreadMain,(void*)(long)i)
  io_threads[i] = tid;
 }
}

1)创建线程函数讲解

创建线程具体调用的是 pthread_create 函数,pthread_create 是在 glibc 库中实现的。在 glibc 库中,pthread_create 函数的实现调用路径是 __pthread_create_2_1 -> create_thread。其中 create_thread 这个函数比较重要,它设置了创建线程时使用的各种 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);

 int res = do_clone (pd, attr, clone_flags, start_thread,
      STACK_VARIABLES_ARGS, 1);
 ...
}

在上面的代码中,传入参数中的各个 flag 标记是非常关键的。

2)线程创建的标记

 CLONE_PARENT  创建的子进程的父进程是调用者的父进程,新进程与创建它的进程成了“兄弟”而不是“父子”
 CLONE_FS          子进程与父进程共享相同的文件系统,包括root、当前目录、umask
 CLONE_FILES     子进程与父进程共享相同的文件描述符(file descriptor)表
 CLONE_NEWNS  在新的namespace启动子进程,namespace描述了进程的文件hierarchy
 CLONE_SIGHAND  子进程与父进程共享相同的信号处理(signal handler)表
 CLONE_PTRACE  若父进程被trace,子进程也被trace
 CLONE_VFORK    父进程被挂起,直至子进程释放虚拟内存资源
 CLONE_VM          子进程与父进程运行于相同的内存空间
 CLONE_PID         子进程在创建时PID与父进程一致
 CLONE_THREAD   Linux 2.4中增加以支持POSIX线程标准,子进程与父进程共享相同的线程群
 CLONE_VM 0x00000100 置起此标志在进程间共享地址空间
CLONE_FS 0x00000200 置起此标志在进程间共享文件系统信息
CLONE_FILES 0x00000400 置起此标志在进程间共享打开的文件
CLONE_SIGHAND 0x00000800 置起此标志在进程间共享信号处理程序

接下来的 do_clone 最终会调用一段汇编程序,在汇编里进入 clone 系统调用,之后会进入内核中进行处理。

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

二、内核中对线程的数据结构表示

在开始介绍线程的创建过程之前,先给大家看看内核中表示线程的数据结构。开篇的时候我说了,进程和线程的相同点要远远大于不同点。主要依据就是在 Linux 中,无论进程还是线程,都是抽象成了 task 任务,在源码里都是用 task_struct 结构来实现的。
在这里插入图片描述

1)task_struct具体定义

我们来看 task_struct 具体的定义,它位于 include/linux/sched.h

//file:include/linux/sched.h
struct task_struct {
 //1.1 task状态 
 volatile long state;

 //1.2 进程线程的pid
 pid_t pid;  //自己的进程ID
 pid_t tgid; //父进程的ID

 //1.3 task树关系:父进程、子进程、兄弟进程
 struct task_struct __rcu *parent;
 struct list_head children; 
 struct list_head sibling;
 struct task_struct *group_leader; 

 //1.4 task调度优先级
 int prio, static_prio, normal_prio;
 unsigned int rt_priority;

 //1.5 地址空间
 struct mm_struct *mm, *active_mm;

 //1.6 文件系统信息(当前目录等)
 struct fs_struct *fs;

 //1.7 打开的文件信息
 struct files_struct *files;

 //1.8 namespaces 
 struct nsproxy *nsproxy;

 ...
}

2)task_struct 数据结构分拆讲解及对应逻辑

(1)进程线程状态
  • 流程
    ①一个任务(进程或线程)刚创建出来的时候是 TASK_RUNNING 就绪状态,等待调度器的调度。调度器执行 schedule 后,任务获得 CPU 后进入 执行进行运行。当需要等待某个事件的时候,例如阻塞式 read 某个 socket 上的数据,但是数据还没有到达的时候,任务进入 TASK_INTERRUPTIBLE 或 TASK_UNINTERRUPTIBLE 状态,任务被阻塞掉。
    ②当等待的事件到达以后,例如 socket 上的数据到达了。内核在收到数据后会查看 socket 上阻塞的等待任务队列,然后将之唤醒,使得任务重新进入 TASK_RUNNING 就绪状态。任务如此往复地在各个状态之间循环,直到退出。
    在这里插入图片描述

  • 状态值定义
    全部的状态值在 include/linux/sched.h 中进行了定义。


//file:include/linux/sched.h
#define TASK_RUNNING            0
#define TASK_INTERRUPTIBLE      1
#define TASK_UNINTERRUPTIBLE    2
#define __TASK_STOPPED  4
#define __TASK_TRACED  8
...

#define TASK_DEAD  64
#define TASK_WAKEKILL  128
#define TASK_WAKING  256
#define TASK_PARKED  512
#define TASK_STATE_MAX  1024
......
(2)进程 ID

每一个进程都有一个进程 id 的概念。在 task_struct 中有两个相关的字段,分别是 pid 和 tgid

  • 代码
//file:include/linux/sched.h
struct task_struct {
 ......
 pid_t pid;
 pid_t tgid;
}
  • pid唯一标识一个线程、进程
    其中 pid 是 Linux 为了标识每一个进程而分配给它们的唯一号码,称做进程 ID 号,简称 PID。对于没有创建线程的进程(只包含一个主线程)来说,这个 pid 就是进程的 PID,tgid 和 pid 是相同的(tgid是父进程号)
(3)进程树关系
  • 进程树介绍
    在 Linux 下所有的进程都是通过一棵树来管理的。在操作系统启动的时候,会创建 init 进程,接下来所有的进程都是由这个进程直接或者间接创建的的。通过 pstree 命令可以查看你当前服务器上的进程树信息。
init-+-atd
  |-cron
  |-db2fmcd
  |-db2syscr-+-db2fmp---4*[{db2fmp}]
  |          |-db2fmp---3*[{db2fmp}]
  |          |-db2sysc---13*[{db2sysc}]
  |          |-3*[db2syscr]
  |          |-db2vend
  |          `-{db2syscr}
  |-dbus-daemon
  • 线程关系图介绍
    那么,这棵进程树就是由 task_struct 下的 parent、children、sibling 等字段来表示的。这几个字段将系统中的所有 task 串成了一棵树
    在这里插入图片描述
(4)进程调度优先级
  • 介绍
    在 task_struct 中有几个字段是表示进程优先级的,在进程调度的时候会根据这几个字段来决定优先让哪个任务(进程或线程)开始执行。

  • 代码

 //1.4 task调度优先级
 int prio, static_prio, normal_prio;
 unsigned int rt_priority;
  • 参数介绍
    1)static_prio: 用来保存静态优先级,可以调用 nice 系统直接来修改取值范围为 100~139
    2)rt_priority: 用来保存实时优先级,取值范围为 0~99
    3)prio: 用来保存动态优先级
    4)normal_prio: 它的值取决于静态优先级和调度策略
(5)进程地址空间
  • 介绍
    对于用户进程来讲,内存描述符 mm_struct( mm 代表的是 memory descriptor)是非常核心的数据结构。整个进程的虚拟地址空间部分都是由它来表示的。

  • 进程地址空间作用
    进程在运行的时候,在用户态其所需要的代码,全局变量数据,以及 mmap 内存映射等全部都是通过 mm_struct 来进行内存查找和寻址的。这个数据结构的定义位于 include/linux/mm_types.h 文件下。

  • 代码

//file:include/linux/mm_types.h
struct mm_struct {
 struct vm_area_struct * mmap;  /* list of VMAs */
 struct rb_root mm_rb;

 unsigned long mmap_base;  /* base of mmap area */
 unsigned long task_size;  /* size of task vm space */
 unsigned long start_code, end_code, start_data, end_data;
 unsigned long start_brk, brk, start_stack;
 unsigned long arg_start, arg_end, env_start, env_end;
}
  • 参数解释
1)start_code  代码段的开始
2)end_code   代码段结束
3)start_data  数据段开始
4)end_data   数据段结束
5)start_stack 是用户态堆栈的起始地址
6)start_brk 和 brk 中间是堆内存的位置
  • 整个进程地址空间的地址示意图
    在这里插入图片描述

  • 注意(所有内核进程、用户态进程的内核态这部分内存是共享的)
    在这里插入图片描述

  • 内核线程没有虚拟地址空间,所以mm是null

(6)进程文件系统信息(当前目录等)
  • 定义
    进程的文件位置等信息是由 fs_struct 来描述的,它的定义位于 include/linux/fs_struct.h 文件中。

  • 代码

//file:include/linux/fs_struct.h
struct fs_struct {
 ...
 struct path root, pwd;
};

//file:include/linux/path.h
struct path {
 struct vfsmount *mnt;
 struct dentry *dentry;
};
  • 参数解释
    通过以上代码可以看出,在 fs_struct 中包含了两个 path 对象,而每个 path 中都指向了一个 struct dentry。在 Linux 内核中,denty 结构是对一个目录项的描述。
    在这里插入图片描述
    拿 pwd 来举例,该指针指向的是进程当前目录所处的 denty 目录项。假如我们在 shell 进程中执行 pwd,或者用户进程查找当前目录下的配置文件的时候,都是通过访问 pwd 这个对象,进而找到当前目录的 denty 的。
(7)进程打开的文件信息(略)
(8)namespaces(略)

3)线程与进程的区别

  • 相同点
    1)对于线程来讲,所有的字段都是和进程一样的(本来就是一个结构体来表示的)。包括状态、pid、task 树关系、地址空间、文件系统信息、打开的文件信息等等字段,线程也都有。
    2)进程和线程的相同点要远远大于不同点,本质上是同一个东西,都是一个 task_struct !正因为进程线程如此之相像,所以在 Linux 下的线程还有另外一个名字,叫轻量级进程。至于说轻量在哪儿,稍后我们再说。

  • 不同点
    1)pid 和 tgid 这两个字段。在 Linux 中,每一个 task_struct 都需要被唯一的标识,它的 pid 就是唯一标识号。对于进程来说,这个 pid 就是我们平时常说的进程 pid。对于线程来说,我们假如一个进程下创建了多个线程出来。那么每个线程的 pid 都是不同的。但是我们一般又需要记录线程是属于哪个进程的。这时候,tgid 就派上用场了,通过 tgid 字段来表示自己所归属的进程 ID。
    在这里插入图片描述
    这样内核通过 tgid 可以知道线程属于哪个进程。

三、进程、线程创建过程及异同

1)进程创建(用到do_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, ...);
 ...
}

2)线程的创建(也是用到do_fork)

我们在本文第一小节里介绍到 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);

 int res = do_clone (pd, attr, clone_flags, ...);
 ...
}

好,我们找到 clone 系统调用的实现

SYSCALL_DEFINE5(clone, ......)
{
 return do_fork(clone_flags, newsp, 0, parent_tidptr, child_tidptr);
}

同样,do_fork 函数还是会执行到 copy_process 来完成实际的创建。

3)进程线程创建异同(传入do_fork的标记不一样)

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

  • 传入标记不一样
    不过创建过程的区别是二者在调用 do_fork 时传入的 clone_flags 里的标记不一样!
1)创建进程时的 flag:仅有一个 SIGCHLD
2)创建线程时的 flag:包括 CLONE_VM、CLONE_FS、CLONE_FILES、CLONE_SIGNAL、
CLONE_SETTLS、CLONE_PARENT_SETTID、CLONE_CHILD_CLEARTID、
CLONE_SYSVSEM。
  • 部分标记含义
关于这些 flag 的含义,我们选几个关键的做一个简单的介绍,后面介绍 do_fork 细节的时
候会再次涉及到。
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);
 ...
}
  • 接下来根据标记看是否执行拷贝对应的数据
//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 。接下来我们分小节来查看该函数的每一个细节。

1)复制 task_struct 结构体

  • (1)整体入口
//file:kernel/fork.c
static struct task_struct *dup_task_struct(struct task_struct *orig)
{
 //1、申请 task_struct 内核对象(slab线程解析)
 tsk = alloc_task_struct_node(node);
 //2、复制 task_struct
 err = arch_dup_task_struct(tsk, orig);
 ...
}
  • (2)分配内存
    其中 alloc_task_struct_node 用于在 slab 内核内存管理区中申请一块内存出来。关于 slab 机制请参考- 内核内存管理
//file:kernel/fork.c
static struct kmem_cache *task_struct_cachep;
static inline struct task_struct *alloc_task_struct_node(int node)
{
 return kmem_cache_alloc_node(task_struct_cachep, GFP_KERNEL, node);
}
  • (3)对分配内存后的struct进行内存拷贝

//file:kernel/fork.c
int arch_dup_task_struct(struct task_struct *dst,
         struct task_struct *src)
{
 *dst = *src;
 return 0;
}

2)拷贝打开文件列表(创建进程就没有传入CLONE_FILES标记,进程不会共用file_struct)

创建线程调用 clone 系统调用的时候,传入了一堆的 flag,其中有一个就是 CLONE_FILES。如果传入了 CLONE_FILES 标记,就会复用当前进程的打开文件列表 - files 成员。

在这里插入图片描述
对于创建进程来讲,没有传入这个标志,就会新创建一个 files 成员出来
在这里插入图片描述
好了,我们继续看 copy_files 具体实现。


//file:kernel/fork.c
static int copy_files(unsigned long clone_flags, struct task_struct *tsk)
{
 struct files_struct *oldf, *newf;
 oldf = current->files;

 if (clone_flags & CLONE_FILES) {
  atomic_inc(&oldf->count);
  goto out;
 }
 newf = dup_fd(oldf, &error);
 tsk->files = newf;
 ...
}

从代码看出,如果指定了 CLONE_FILES(创建线程的时候),只是在原有的 files_struct 里面 +1 就算是完事了,指针不变,仍然是复用创建它的进程的 files_struct 对象

  • 重要点
    这就是进程和线程的其中一个区别,对于进程来讲,每一个进程都需要独立的 files_struct。但是对于线程来讲,它是和创建它的线程复用 files_struct 的。

3)拷贝文件目录信息

再回忆一下创建线程的时候,传入的 flag 里也包括 CLONE_FS。如果指定了这个标志,就会复用当前进程的文件目录 - fs 成员。

在这里插入图片描述
对于创建进程来讲,没有传入这个标志,就会新创建一个 fs 出来。

在这里插入图片描述
好,我们继续看 copy_fs 的实现。

//file:kernel/fork.c
static int copy_fs(unsigned long clone_flags, struct task_struct *tsk)
{
 struct fs_struct *fs = current->fs;
 if (clone_flags & CLONE_FS) {
  fs->users++;
  return 0;
 }
 tsk->fs = copy_fs_struct(fs);
 return 0;
}

和 copy_files 函数类似,在 copy_fs 中如果指定了 CLONE_FS(创建线程的时候),并没有真正申请独立的 fs_struct 出来,近几年只是在原有的 fs 里的 users +1 就算是完事。

  • 这里进程和线程的区别
    而在创建进程的时候,由于没有传递这个标志,会进入到 copy_fs_struct 函数中申请新的 fs_struct 并进行赋值拷贝。

4)拷贝内存地址空间(创建线程带 CLONE_VM ,表示和当前线程共享一份地址空间mm_struct)

创建线程的时候带了 CLONE_VM 标志,而创建进程的时候没带。接下来在 copy_mm 函数 中会根据是否有这个标志来决定是该和当前线程共享一份地址空间 mm_struct,还是创建一份新的。

//file:kernel/fork.c
static int copy_mm(unsigned long clone_flags, struct task_struct *tsk)
{
 struct mm_struct *mm, *oldmm;
 oldmm = current->mm;

 if (clone_flags & CLONE_VM) {
  atomic_inc(&oldmm->mm_users);
  mm = oldmm;
  goto good_mm;
 }
 mm = dup_mm(tsk);
good_mm:
 return 0; 
}

对于线程来讲,由于传入了 CLONE_VM 标记,所以不会申请新的 mm_struct 出来,而是共享其父进程的。
在这里插入图片描述

  • 线程共享父进程地址地址空间
    多线程程序中的所有线程都会共享其父进程的地址空间。

在这里插入图片描述

  • 而对于多进程程序来说,每一个进程都有独立的 mm_struct(地址空间)
    在这里插入图片描述
    因为在内核中线程和进程都是用 task_struct 来表示,只不过线程和进程的区别是会和创建它的父进程共享打开文件列表、目录信息、虚拟地址空间等数据结构,会更轻量一些。所以在 Linux 下的线程也叫轻量级进程

  • 线程与进程区别
    在打开文件列表、目录信息、内存虚拟地址空间中,内存虚拟地址空间是最重要的。因此区分一个 Task 任务该叫线程还是该叫进程,一般习惯上就看它是否有独立的地址空间。如果有,就叫做进程,没有,就叫做线程。
    (这里展开多说一句,对于内核任务来说,无论有多少个任务,其使用地址空间都是同一个。所以一般都叫内核线程,而不是内核进程。)

五 结论

1)线程

  • 对于线程:地址空间、目录信息、打开文件fd列表和父进程共享
    (创建线程的整个过程我们就介绍完了。回头总结一下,对于线程来讲,其地址空间 mm_struct、目录信息 fs_struct、打开文件列表 files_struct 都是和创建它的任务共享的。)
    在这里插入图片描述

2)进程

  • 对于进程:地址空间、目录信息、打开文件fd列表都是独立需要额外内存初始化的
    (对于进程来讲,地址空间 mm_struct、挂载点 fs_struct、打开文件列表 files_struct 都要是独立拥有的,都需要去申请内存并初始化它们。)

在这里插入图片描述

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

3)线程和进程切换相差多少?

  • 线程和进程切换相差多少?
    那么线程具体能轻量多少呢?我之前曾经做过一个进程和线程的上下文切换开销测试。进程的测试结果是一次上下文切换平均 2.7 - 5.48 us 之间。线程上下文切换是 3.8 us左右。总的来说,进程线程切换还是没差太多。参见《进程/线程切换究竟需要多少开销?》
  • 1
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值