【Linux】线程

一.线程概念

我们在学习进程的时候已经知道了，进程=内核数据结构pcb+自己的代码和数据。那么单单一个task_struct是什么呢？

我们将单个的task_struct叫做轻量级进程，而这个轻量级进程也叫做线程。以往我们在了解进程的时候，一个进程内部都只有一个task_struct，也就是一个进程内部只有一个线程。而这其实是一种特殊情况。更一般的情况下，一个进程内部有多个线程共享同一个虚拟地址空间。

我们在访问系统资源的时候，大部分都是通过虚拟地址空间来访问的。也就是说虚拟地址空间是资源的窗口，进程内部的所有的线程都可以看到该窗口，即都可以访问该进程的资源。每一个线程有自己的入口函数，对于主进程来说，它的入口就是main函数。而线程执行不同的代码和数据，本质就是在进程内部对资源的划分，其实就是对地址空间的划分，每个线程都执行分给自己的那部分虚拟地址。

在创建进程的时候，我们要创建内核数据task_struct，创建虚拟地址空间，加载物理内存等等，而这些都是系统资源。所以，进程是承担分配的系统资源的基本实体！线程是进程内部的一个执行流分支，是cpu调度的基本单位。

也就是说，站在cpu的角度，它不用区分当前占用cpu资源的到底是进程还是线程了，cpu只关心一个一个的执行流。无论一个进程内部有多个执行流，cpu都是以task_struct为基本单位进行调度的，也就是线程。

Linux操作系统实现线程的方式是利用已有的进程的代码，进行复用，用进程来模拟线程。Linux操作系统中没有线程的概念，只有轻量级进程的概念，它是利用系统调用在用户层实现了用户级线程。

而在windows下，专门设计出了tcb结构用来描述线程。一个进程pcb中，还包含了一个tcb的链表结构，保存了该进程内部的所有的线程。windows这样的设计无异于让进程和线程变得更加复杂了。

二.分页式存储管理 

1.分页式管理

学到这里，我已经知道，我们对物理内存的管理实际上是通过虚拟地址空间再加上页表的映射来实现的。

我们的二进制文件在磁盘上是以4kb为单位的数据块存储的，而运行可执行程序，其向内存中加载到时候也是以4kb为单位的，并且物理内存也被分成了以4kb为基本单位的内存块。

我们将这个4kb的基本内存块或者数据块叫做页框或者页帧。

假设我们的物理内存有4GB，一个页框的大小是4kb，那么整个物理内存就被分为了1048576个页框。

这么多页框，操作系统要对其进行管理，所以先描述，再组织。在Linux操作系统中，就是通过page结构体来描述一个一个的页框的。

struct page
{/* 原⼦标志，有些情况下会异步更新 */unsigned long flags;union{struct{/* 换出⻚列表，例如由zone->lru_lock保护的active_list */struct list_head lru;/* 如果最低为为0，则指向inode* address_space，或为NULL* 如果⻚映射为匿名内存，最低为置位* ⽽且该指针指向anon_vma对象*/struct address_space *mapping;/* 在映射内的偏移量 */pgoff_t index;/** 由映射私有，不透明数据* 如果设置了PagePrivate，通常⽤于buffer_heads* 如果设置了PageSwapCache，则⽤于swp_entry_t* 如果设置了PG_buddy，则⽤于表⽰伙伴系统中的阶*/unsigned long private;};struct{ /* slab, slob and slub */union{struct list_head slab_list; /* uses lru */struct{ /* Partial pages */struct page *next;
#ifdef CONFIG_64BITint pages;    /* Nr of pages left */int pobjects; /* Approximate count */
#elseshort int pages;short int pobjects;
#endif};};struct kmem_cache *slab_cache; /* not slob *//* Double-word boundary */void *freelist; /* first free object */union{void *s_mem;            /* slab: first object */unsigned long counters; /* SLUB */struct{                        /* SLUB */unsigned inuse : 16; /* ⽤于SLUB分配器：对象的数⽬ */unsigned objects : 15;unsigned frozen : 1;};};};...};union{/* 内存管理⼦系统中映射的⻚表项计数，⽤于表⽰⻚是否已经映射，还⽤于限制逆向映射搜索*/atomic_t _mapcount;unsigned int page_type;unsigned int active; /* SLAB */int units;           /* SLOB */};...
#if defined(WANT_PAGE_VIRTUAL)/* 内核虚拟地址（如果没有映射则为NULL，即⾼端内存） */void *virtual;
#endif /* WANT_PAGE_VIRTUAL */...
}

page中有一个flags标志位，它表明了该页的状态，是被使用了，还是没有被使用，还是只读的等等！ 

那操作系统是怎么将这么多的页管理起来的呢？通过一个全局的数组。struct page mem[1048576]；这样，每一个page都会有一个下标，我们里利用下标*4kb，就可以拿到指定下标page的起始地址。

但是我们在使用虚拟地址时，都是访问某一个或者几个具体的字节，而不是一整个页框，所以，在page中，我们通过页框的起始物理地址+页内的偏移量，就可以访问到具体的某个字节。

 2.页表

我们访问物理内存都是通过访问虚拟地址+页表进行虚拟到物理内存的转化来实现的。那么页表的结构到底是什么呢？

Linux中的页表采取的是2级页表，分为外级页表和内级页表，外级页表叫做页目录，它保存的表项是内级页表，而内级页表叫做页表，它保存的表项为页框起始地址。

而在32位机器下，地址的大小是4字节，也就是32个比特位。当我们进行虚拟地址到物理地址的转换时：前10个比特位，范围[0,1023]共1024个，用来查找对应的页目录，中间10个比特位，用来查询页目录指定的页表，通过这一阶段，我们就找到了要访问的虚拟地址在物理内存中的页框。

但我们访问的是具体的字节，这就用到了剩下的12个比特位。这12个bit位一共有4kb个组合，正好对应一个页框的大小，它起始就是页内偏移量。这时虚拟转换为物理的第二阶段。

所以，我们是如何通过访问虚拟地址，间接访问物理内存的呢？

当我们访问虚拟地址的时候，cpu中的内存管理单元(MMU)会先拿着虚拟地址的前10位作为下标，查看页目录而页目录会保存在cpu的CR3寄存器中，找到对应页表的起始地址，再拿着中间10位作为下标查看页表，找到指定的页框，再通过最后12的页内偏移就可以找到页框内的具体字节。

单级页表会消耗大量内存空间，而多级页表会因为多次查询导致效率降低。而在计算机科学中，任何问题都可以通过加一个中间层来解决。

MMU引入了新武器，江湖人称快表的TLB（其实，就是缓存）。

当CPU给MMU传新虚拟地址之后，MMU先去问TLB那边有没有，如果有就直接拿到物理地址，但是TLB容量比较小，难免会遇到Cache Miss(缓存未命中)，这时候MMU还有保底的老武器——页表，在页表中找到之后MMU除了拿到该物理地址进行使用外，还会把这条映射关系保存到TLB中。

三.线程的优缺点 

1.线程的优点

0x1.创建一个新线程的代价要比创建一个新进程小的多。

创建一个新进程只需要创建一个轻量级进程-task_struct就行了。而创建一个新进程不仅要创建内核数据结构，还得创建虚拟地址空间、加载物理内存等等操作。

0x2.线程占用的资源要比进程少的多

线程是进程中的一个执行单元，线程共享该进程内的所有资源，但也有自己独立的栈结构和上下文数据。

0x3.计算密集型应用，为了能在多处理器系统上运行，将计算分解到多个线程中实现。

对于复杂的计算任务，如科学计算、机器学习算法中的矩阵乘法、物理模拟等，可将任务分解为多个子任务，每个子任务由一个线程处理，实现并行计算，减少任务的总体执行时间。

0x4.I/O密集型应用，为了提高性能，将I/O操作重叠，线程可以同时等待不同的I/O操作。

在 I/O 密集型应用中，程序经常需要等待 I/O 操作完成，如从磁盘读取文件、向网络发送数据等。如果使用单线程，在等待 I/O 操作完成期间，CPU 将处于空闲状态，资源利用率较低。而多线程可以充分利用 CPU 资源。当一个线程等待 I/O 操作时，其他线程可以继续执行，CPU 可以在不同线程之间切换，避免因等待 I/O 而导致的 CPU 空闲，从而提高 CPU 的利用率。

 0x5.线程的切换比进程的切换效率要高得多

当切换线程的时候，因为共享地址空间，所以只需要保存cpu的硬件上下文数据到线程的task_struct中即可。切换进程的时候，当然也需要保存cpu的硬件上下文数据，到pcb中的，但除了这些还需要切换页表，物理内存、虚拟地址空间等资源。

还有一些切换的隐藏的损耗就是缓存失效。当我们借助虚拟地址访问资源的时候，cpu中会有cache缓存将你要访问的资源那个页框都加载到缓存中。而当线程切换的时候，因为共享地址空间，所以cache缓存多少会有点用，但是对于进程切换来说，它的整个虚拟地址都变了，所以cache缓存就失效了，此时访问虚拟地址效率就比较低了，需要重新进行缓存。TLB快表页如此，进程切换之后，虚拟到物理的转换也变慢了。

2.线程的缺点 

0x1.性能损失

并不是线程越多越好，如果线程的数量比处理器的数量多，此时仍会有多个执行流闲置。并且频繁的切换线程也是会有消耗的

0x2.缺乏访问控制

多个线程可以同时访问和修改共享的变量或数据结构，如果缺乏适当的访问控制机制，就可能出现数据竞争问题。例如，两个线程同时对一个共享的计数器进行递增操作，可能会导致计数器的最终值比预期的要小，因为线程之间的操作相互干扰。所以，使用多线程可能会导致代码的健壮性降低。

当一个进程中的任意一个线程收到信号/或者异常了，整个进程就会结束。因为信号是发送给进程的。

3.进程和线程

进程是系统资源分配的基本实体，线程是进程的执行流分支，是cpu的基本调度单位。进程之间是相互独立的，资源互相不可见。而同一个进程中的线程，共享整个地址空间，但每个线程还有自己独立的数据/代码：

• 线程ID
• 一组寄存器：cpu调度的基本单位是线程，线程就是轻量级进程task_struct。当cpu进行切换的时候，需要把线程的上下文保存在自己的数据结构中。以便下一次继续执行。
• 线程栈
• errno
• 信号屏蔽字
• 调度优先级

四.线程控制 

demo

#include <iostream>
#include <string>
#include <pthread.h>
#include <unistd.h>// 新线程入口
void* routine(void* arg)
{std::string name = static_cast<char*>(arg);std::cout << "i am " << name << std::endl;sleep(10);return nullptr;
}int main()
{// 创建线程pthread_t tid;pthread_create(&tid, nullptr, routine, (void*)"thread-1");std::cout << "i am main thread" << std::endl; // 回收线程pthread_join(tid, nullptr);return 0;
}

说明：因为Linux是用轻量级进程模拟实现的线程，所以在Linux操作系统中并没有创建现成的系统调用。只有创建轻量级进程的系统调用。所以我们上面使用的pthread库其实是对Linux操作系统轻量级进程的封装，实现了用户级的线程。

我们可以使用ps -aL来查看当前的所有线程：

 因为pthread库是第三库，所以我们在编译的时候需要加上 -l pthread选项。

我们看图发现，这两个线程的pid是一致的，它们是属于同一个进程的。第二个LWP的意思是light weight process 轻量级进程，我们看到第一个相乘的lwp与进程pid相同，说明它是主线程。 

下面是Linux操作系统提供的创建轻量级进程的系统调用。 

NAMEvfork - create a child process and block parentSYNOPSIS#include <sys/types.h>#include <unistd.h>pid_t vfork(void);NAMEclone, __clone2, clone3 - create a child processSYNOPSIS/* Prototype for the glibc wrapper function */#define _GNU_SOURCE#include <sched.h>int clone(int (*fn)(void *), void *stack, int flags, void *arg, .../* pid_t *parent_tid, void *tls, pid_t *child_tid */ );

c++11还提供了多线程，这个库是语言提供的。所以它得适配所有的平台。在Windows下，因为本来就又线程这个具体的概念，所以在Windows下就是通过封装线程的接口实现的。而在Linux操作系统下，因为没有具体的线程概念，线程是通过轻量级进程实现的，所以只有pthread库来实现线程操作，那么对于C++11而言，要想提供语言级的线程库，就只能对pthread库进行封装了。

1.线程控制接口

0x1.pthread_create()

NAMEpthread_create - create a new threadSYNOPSIS#include <pthread.h>int pthread_create(pthread_t *thread, const pthread_attr_t *attr,void *(*start_routine) (void *), void *arg);RETURN VALUEOn success, pthread_create() returns 0; on error, it returns an error number, and the contents of *thread are undefined.

创建一个新线程

• pthread_t * thread：线程id，输出型参数
• *attr：创建线程的具体属性，我们不管，直接传nullptr即可
• start_routine：函数指针，参数和返回值都是void*，作为新线程的入口函数
• arg：新线程入口函数的参数

其实pthread_t其实就是一个无符号长整数。 

如上图，我们创建线程之后，主线程继续向下执行，而新线程的入口函数为routine，就跳转到该函数进行执行，执行完后，该线程也就结束了。但是观察打印的结果，我们有三个问题：

1.线程id为什么这么大，为什么不用lwp

lwp是轻量级进程的概念，如果直接将lwp作为线程id，这让没有了解过Linux操作系统的人会产生误解。而线程id到底是什么，后面再说。

2.主线程和新线程消息混在一起

因为主新线程共享同一个地址空间，也就共享同一个文件描述符表，它们都可以向显示器文件打印信息，但这也说明它们不是原子的，导致了数据的不一致。

3.收到信号， 进程直接退出。

信号是发送给进程的，进程收到信号会结束，线程自然也就结束了。当进程中，任意一个线程异常了，整个进程也会退出。

4.线程时间片

时间片是用来切换线程的计数器。在进程切换时，我们说当一个进程的时间片超时了，就切换另一个进程。而当一个进程内部有多个线程时，每个线程平分进程的时间片 

0x2.pthread_join

当线程从入口函数进入，执行完该函数后，就表明该线程结束了，与子进程结束父进程要等待一样，新线程结束了，主线程要对新线程进行等待，回收新线程的资源。如果不回收，就会产生类似僵尸进程的结果，也就是内存泄露问题。

NAMEpthread_join - join with a terminated threadSYNOPSIS#include <pthread.h>int pthread_join(pthread_t thread, void **retval);

• thread：回收的线程id
• retval：用于接收线程的退出信息。线程结束返回void*，可以利用该函数的输出型参数拿到

线程结束我们无法直接观察到类似僵尸进程的结果，但是我们要记住要等待新线程，避免内存泄露。

0x3.线程终止 

当我们的创建的新线程执行到入口函数的return语句就表示该线程终止了。当然，还有一些接口可以让我们手动终止线程：

NAMEpthread_exit - terminate calling threadSYNOPSIS#include <pthread.h>void pthread_exit(void *retval);NAMEpthread_cancel - send a cancellation request to a threadSYNOPSIS#include <pthread.h>int pthread_cancel(pthread_t thread);

pthread_exit让一个线程终止，其会返回void*参数到主线程

pthread_cancel取消一个线程，一般是主线程去取消其他新进程，取消之前需要保证该线程已经启动。

 0x4.线程分离

在父子进程，子进程结束父进程要等待子进程，子进程结束会向父进程发送SIGCHLD信号，如果父进程不关心子进程的退出信息，就可以采取忽略捕捉该信号，子进程就不会进入僵尸状态，直接退出。

在线程这里，主线程等待新线程时只能阻塞式的等待，无法向进程那样非阻塞等待，当我们不关心其他线程的返回结果时，阻塞等待非常浪费效率。所以我们可以让线程进行分离，分离之后，主新线程还是共享地址空间，只不过此时主线程就不必等待新进程了，新进程退出后，会直接释放其内核数据结构。

NAMEpthread_detach - detach a threadSYNOPSIS#include <pthread.h>int pthread_detach(pthread_t thread);NAMEpthread_self - obtain ID of the calling threadSYNOPSIS#include <pthread.h>pthread_t pthread_self(void);

线程分离需要提供线程id，所以我们自然可以让主线程分离新线程。但pthread库还提供了pthread_slef接口，用来获取调用该接口的线程的线程id，这样我们也可以实现新线程主动分离主线程。

需要注意的是，一个进程不能既是joinable又是分离的，也就是说当一个线程分离了，我们就不能再join了，这样的行为是未定义的。

 五.线程id及进程地址空间分布

Linux操作系统没有实际上的线程，是借助轻量级线程模拟的，所以就有了pthread原生线程库。既然是动态库，那么就是ELF格式的，当我们使用该库时，要将其加载到内存，同时将该库映射到该进程的虚拟地址空间上的共享区或者mmap动态区域。

因为动态库只会在内存中存在一份，所以所有的进程共享这一份pthread动态库。并且，线程这个概念是在库中定义的。所以，这个库中会包含许多的线程。那么我们就要对线程进行管理——先描述，再组织。

怎么理解在库中定义了线程呢？我们可以想想之前的FILE* fp = open；打开一个文件，其实就是为我们申请了一个FILE结构体对象，充当用户级缓冲区。所以对于在库中定义了线程，可以理解为我们使用pthread_create创建一个新线程，本质上就是为我们申请了一个strcut tcb结构体对象。

我们之间还说过，线程共享地址空间，但仍有自己独立的资源。比如独立的栈空间，独立的存储位置。

所以，为什么线程结束后需要join呢？因为库中的tcb结构，以及独立的资源需要被释放。

所以，线程id其实就是线程对应tcb控制块的虚拟地址。

所以，因为线程有自己独立的控制块和栈空间，线程在入口函数return 之后，会将内容保存在自己的存储空间中，然后我们主线程在join的时候又会从线程的存储空间中，拿出该退出信息。当我们创建新线程时也一样！！！

因为pthread库是对轻量级进程的接口的封装，所以我们在main函数中，pthread_create创建新线程的时候，除了创建线程控制块，还要调用底层封装的轻量级进程的系统调用，创建轻量级进程（task_struct）。

六.线程栈与线程局部存储

1.线程栈

除了主线程使用进程在地址空间上向下增长的栈空间外，其余的线程都是用自己独立的栈结构，虽然我们画图是将创建线程时的控制块和局部存储、线程栈画在了一起，但实际上，它们在库中并不连续，tcb中有指针指向线程自己独立的栈结构以及栈的大小。

主线程使用的栈空间是可以向下增长的，而新线程的栈空间是mmap出来的，大小是固定的，也可以在创建的时候指定大小。

虽然说是每一个线程独立的栈结构，但是所有的线程都共享该地址空间，且pthread库映射到了0~3GB的用户空间，其他线程是可以看到别的线程的栈上的数据的，但前提是得能拿到虚拟地址。

2.线程局部存储

线程局部存储（Thread - Local Storage，TLS）是一种为每个线程提供独立数据副本的技术，每个线程对自己的数据副本进行读写操作，不会影响其他线程的数据副本。比如说，我们有一个全局的变量，所有的进程共享该变量，都可以对该变量进行读写，且都是同时变化的。如果我们想让该变量不在因为其他线程修改了，所有的都要改变，就可以使用TLS。

使用场景：

当需要每个线程都有自己的特定数据，且这些数据不需要被其他线程访问或者每个线程对这些数据的操作相互独立时，TLS 就非常有用。例如，一些函数库可能需要为每个线程维护一些内部状态信息，像随机数生成器的种子、线程私有的缓冲区等，这时候就可以使用 TLS。

demo：

#include <iostream>
#include <pthread.h>
#include <unistd.h>int cnt = 0;// 线程1，修改并读cnt
void* routine1(void*)
{while(true){std::cout << "thread-1," << "cnt->" << cnt++ << std::endl;sleep(1);}return nullptr;
}// 线程2，只读cnt
void* routine2(void*)
{while(true){std::cout << "thread-2," << "cnt->" << cnt << std::endl;sleep(1);}return nullptr;
}int main()
{pthread_t tid1, tid2;pthread_create(&tid1, nullptr, routine1, nullptr);pthread_create(&tid2, nullptr, routine2, nullptr);pthread_join(tid1, nullptr);pthread_join(tid2, nullptr);return 0;
}

说明：分别创建两个线程， 分别对全局变量进行访问，因为线程共享地址空间，所以一个线程修改了全局变量，另一个也会看到。

如果，我们想让每一个线程独立掌握该数据的控制权，线程只修改自己对该数据的副本进行修改，不想影响其他线程，就可以对该全局数据进行__thread修饰。

__thread int cnt = 0;

注意事项：

• 线程局部存储，只能存储内置类型和部分指针 
• 频繁地创建和销毁线程局部存储键或者频繁地访问线程局部存储变量可能会带来一定的性能开销。因为系统需要为每个线程管理这些线程局部存储的数据空间，并且在访问时需要进行额外的查找操作来获取当前线程对应的数据副本。
• 虽然线程局部存储为每个线程提供了独立的数据副本，但如果多个线程之间通过指针或者其他方式间接访问到对方的线程局部存储数据，则仍然可能会出现线程安全问题。所以在使用 TLS 时，要确保线程之间的数据访问是正确的，避免出现数据竞争等情况。

七.封装线程库  

封装线程库时，我们期望在构造的时候就启动新线程，并执行上层所指定的任务。这里的入口函数在实现时不能直接作为普通成员函数，普通成员函数有一个隐藏的this指针，routine的参数就不符合要求了。

所以，我们要将入口函数定义为静态成员函数，这样就没有了this指针的影响力了。因为构造时需要用户传入一个任务，所以我们可以先对返回值为void，无参可调用对象进行包装，并作为成员。这样，我们就可以直接在routine中调用该成员即可。但是因为没有this指针，所以routine无法直接使用成员。这下，我们就可以利用pthread_create的最后一个参数了，该参数最后会传给routine，所以我们将this作为最后一个参数就可以传给routine了。

我们可以使用下面的接口设置和获取线程的名字，以往我们直接启动程序，所有的线程名都是一样的，当我们设置线程名后，就可以看到变化了.方便debug。

NAMEpthread_setname_np, pthread_getname_np - set/get the name of a threadSYNOPSIS#define _GNU_SOURCE             /* See feature_test_macros(7) */#include <pthread.h>int pthread_setname_np(pthread_t thread, const char *name);int pthread_getname_np(pthread_t thread,char *name, size_t len);

#ifndef __THREAD__HPP__
#define __THREAD__HPP__#include <iostream>
#include <string>
#include <functional>
#include <cstdio>
#include <cstring>
#include <pthread.h>namespace MyThread
{static uint32_t cnt = 1;class Thread{private:using func_t = std::function<void()>;static void* routine(void* args){// 静态成员变量没有this指针，无法访问类内成员Thread* self = static_cast<Thread*>(args);pthread_setname_np(self->_tid, self->_name.c_str());self->_func();return nullptr;}public:// 创建线程Thread(func_t func):_isDetach(false),_isRunning(true),_func(func){_name = "thread-" + std::to_string(cnt++);int n = pthread_create(&_tid, nullptr, routine, (void*)this);if(n != 0){std::cerr << "create thread error" << strerror(n) << std::endl;return;}std::cout << "create thread success!" << std::endl;}~Thread(){}// 回收线程bool Join(){// Join线程时，线程必须是joinableif(_isDetach){std::cout << "thread is detached, can not be join" << std::endl;return false;}int n = pthread_join(_tid, nullptr);if(n != 0){std::cerr << "join thread error" << strerror(n) << std::endl;return false;}std::cout << "join thread success!" << std::endl;return true;}// 终止线程bool Stop(){if(_isRunning){int n = pthread_cancel(_tid);if(n != 0){std::cerr << "stop thread error" << strerror(n) << std::endl;return false;}std::cout << "stop thread success!" << std::endl;_isRunning = false;return true;}std::cout << "thread has stopped" << std::endl;return false;}// 分离线程bool Detach(){if(_isDetach){std::cout << "thread is detached" << std::endl;return false;}int n = pthread_detach(_tid);if(n != 0){std::cerr << "detach thread error" << std::strerror(n) << std::endl;return false;}std::cout << "detach thread success!" << std::endl;_isDetach = true;return true;}private:pthread_t _tid;std::string _name;bool _isDetach;bool _isRunning;func_t _func;};}#endif

我们还可以引入模板，在指定任务时，指定任务参数为任意类型，这样就可以从主线程中获取数据，来进行执行，同时也可以用于处理新线程的执行结果。