操作系统：线程

目录

前言： 

1.线程

1.1.初识线程

1.2.“轻量化”进程

1.3.线程与进程

2.线程控制 

2.1.pthread原生线程库

2.2.线程控制的接口 

2.2.1.线程创建

2.2.线程退出|线程等待|线程分离|线程取消

2.3.pthread库的原理

2.4.语言和pthread库的关系

2.5.线程局部存储

前言： 

在前面的学习中，我们知道进程是一种处理任务的执行流，操作系统中的大部分任务都由进程来处理，而进程的创建，需要开辟内存来产生进程PCB、进程虚拟地址空间、页表……，而这个进程的创建成本较大，于是操作系统实现了另一种执行流------线程。

1. 线程是比进程更加轻量化的一种执行流，线程是进程内部的一种执行流。
2. 线程是CPU调度的基本单位，进程是承担系统资源的实体。

那么我们大概就能猜到：进程是线程的载体，操作系统增加了线程这个新的执行流后，进程的角色变为了在系统中创建、获取资源，用来供给线程执行流，实现CPU对线程的不断调度，即：进程是线程的宏观体现？带着这个猜测，我们开始进入线程的学习……

1.线程

1.1.初识线程

在一个程序里的一个执行路线就叫做线程（thread）。更准确的定义是：线程是“一个进程内部的控制序列”

我们在以往的博客中，把进程当做一个执行流来看待，是因为我们在进程中只有一条单一的执行流，当我们在某个进程中创建新的线程之后，就出现了“主线程”和“新线程”，那么这里我们就知道了进程是通过线程来作为执行流的。 

一言以蔽之：对于Linux而言，进程是一个资源的结合体，而线程就是通过这些资源来完成任务的一个个执行流。

比如：有一家大公司，干活的肯定不是大公司，而是公司里的各个部门中的打工人，公司这个进程提供的就是给线程的资源，给线程一个好的平台、环境去发挥。

1.2.“轻量化”进程

在操作系统中，虽然为了解决进程过于笨重的问题，引入了线程的概念，但是线程和进程一样都是一个需要描述的结构，那么进程用process control block（PCB）来描述，那么线程是不是也同样需要TCB这一个数据结构来进行描述呢？

答案：线程也是需要通过数据结构，进行“先描述再组织”的，但是我们实现这个结构可以通过两个方向：1.创建新的TCB体系，实现一份类似于PCB的体系。2.复用当前PCB体系。

对于Windows而言，实现了一个Thread的体系。而Linux则是在PCB的基础上，将线程抽象成“轻量化进程”这个概念，接着复用当前PCB体系……（这里也体现了tast_stuct不完全等于PCB）

如图：对应我们上面所述------Linux对线程的实现是抽象成“轻量化”进程，这是怎么理解的呢？

1. 首先进程拥有它的内核数据结构、代码和数据，所以在空间中需要开辟较多资源来存储
2. “轻量化”体现在于，Linux创建新的线程时，只创建一份新的task_struct，和部分的代码和资源，这样子就能够减少资源的开辟
3. 我们说是创建了新的task_struct，但是实际上这些创建的“轻量化”进程共用着原进程的资源，也就是线程他们是可以访问同一个进程内的数据的。

除了上面的几点，线程的轻量化也体现在CPU的调度上……这里我们需要重点讲解！！！

我们知道：在进程间转换时，CPU在调度不同的进程时需要进行进程相关的上下文切换，以及页表、进程地址空间相关的寄存器内数据的切换……

而线程中的切换，因为访问的是同一个进程的资源，所以大部分的寄存器内容不用修改，这样子线程在CPU切换和调度就显得轻量化了。

实际上：CPU内会维护一块cache缓存，一般情况下CPU是从内存直接读取进程的数据并加载到CPU中，而为了减少IO提高系统效率，所以CPU会将进程的部分代码和数据提前读取进cache中，这部分预加载的代码和数据符合局部性原理。而进程切换，这一块缓存中保存的热数据也需要切换。线程切换并不需要切换cache

面试题：线程切换为什么效率高？

1. 切换的寄存器少
2. 不需要重新更新cache缓存 

1.3.线程与进程

1. 进程是资源分配的基本单位，对于线程而言，进程是线程的载体，给线程提供资源。
2. 线程是调度的基本单位，宏观上是进程被调度，其实在CPU中是通过线程（LWP）来进行任务的调度的
3. 线程共享进程数据，但也拥有自己的一部分数据。

对于第三点，因为线程需要被CPU进行调度，处于多线程时，就需要保存当前线程的上下文（类似进程切换），所以线程会维护一份寄存器的结构体数据。并且因为线程会进行函数的跳转，所以内部也需要一个函数栈结构。另外，线程也维护着优先级、线程id等数据……

如图：即为进程与线程的关系，这就回应了我们在前言中的猜测“进程其实就是线程的载体，进程是线程的宏观体现”。

更加详细的进程与线程的关系：线程与进程，你真得理解了吗_进程和线程的区别-CSDN博客 

2.线程控制 

2.1.pthread原生线程库

在LInux中并没有实现线程这一个模块，而是通过轻量化进程来模拟线程，所以Linux操作系统只提供了“轻量化进程”的系统调用，并没有之间创建线程的接口。因此为了适配不同的开发需求，Linux实现了原生的pthread原生线程库，来实现用户级和系统的轻量化进程的适配，也就是实现了类似于上层C++、Java等面向对象语言的线程！

本质上就是：Linux封装了一层，通过内核中的轻量化进程和Pthread库实现了线程，而不是直接就创建线程这个模块，实现Linux操作系统适配多线程！ 

如图即为：Linux自带的pthread库，所以我们在使用pthread库时，需要连接这个库！！！ 

2.2.线程控制的接口 

2.2.1.线程创建

// 函数原型为pthread_create()
参数分别为：线程tid，栈的地址，调用函数指针，传入参数类型

pthread_create(pthread_t *thread, 
               const pthread_attr_t *attr, 
               void * (*start_routine)(void*), 
               void *arg);

对于进程创建我们需要注意的是：我们需要提前设置tid然后传入，并且传入参数为void*，表示可以传入多种类型的参数，可以是int、string、甚至是自定义的对象！

最基本的进程创建的使用： 

void *ThreadTest1(void *arg)
{
    const char *threadName = (const char *)arg;
    while (1)
    {
        cout << "i am a new thread, mypid is: " << getpid() << ", my name is:" << threadName << endl;
        sleep(1);
        cout << endl;
    };
}
// 线程创建
int main()
{
    // 在main这个进程（主线程）中创建一个新线程
    pthread_t tid;
    // 创建完线程后线程跳转进程ThreadTest函数中
    pthread_create(&tid, nullptr, ThreadTest1, (void *)"Thread one");

    // 主线程
    while (1)
    {
        cout << "my name is Thread main, my pid is: " << getpid() << endl;
        sleep(1);
        cout << endl;
    }
}

 这段代码中我们实现了：两个循环体循环打印各自的内容，这也表示了我们创建了新的执行流，并且他们的进程pid是一致的！

进程创建传入对象参数：

typedef function<void()> func_t;

class ThreadData
{
public:
    ThreadData(const string &name, const uint64_t &ctime, func_t f)
        : thread_name(name), creat_time(ctime), func(f)
    {
    }

    string GetName() const { return thread_name; }
    uint64_t GetTime() const { return creat_time; }
    func_t GetFunc() const { return func; }

private:
    string thread_name;
    uint64_t creat_time;
    func_t func;
};
void Print()
{
    cout << "only print……" << endl;
}
void *ThreadTest2(void *arg)
{
    ThreadData *td = (ThreadData *)arg;
    while (1)
    {
        cout << "当前线程名为：" << td->GetName() << "，创建时间为：" << td->GetTime() << endl;
        (td->GetFunc())();
        sleep(1);
    }
}
// 线程函数是可以传对象作为参数的
int main()
{
    pthread_t tid;
    ThreadData *td = new ThreadData("Thread one", (uint64_t)time(nullptr), Print);

    // 可以传入任意类型的参数
    pthread_create(&tid, nullptr, ThreadTest2, td);

    // 主线程
    while (1)
    {
        cout << "my name is Thread main, my pid is: " << getpid() << endl;
        sleep(3);
        cout << endl;
    }
}

 这段代码的核心和上一个一致，不过这里传入的参数是TreadData这个类的对象，并且在我们给线程完成任务的函数区ThreadTest2中，我们可以接收这个对象并且对这个对象进行操作……实际开发中，线程主要也是通过对传入对象进行操作来实现各种需求的处理的！

2.2.线程退出|线程等待|线程分离|线程取消

线程退出的方式：1.调用的函数完成当前的函数模块，这时会返回nullptr，线程退出。2.通过线程退出函数来实现。另外线程退出不能通过exit函数，exit函数会导致整个进程退出……

// 线程退出函数，填入返回的内容（注意不能返回临时变量）
pthread_exit(void *value_ptr);
// 线程等待函数，传入线程tid，接收的返回值
pthread_join(pthread_t thread, void **value_ptr);

跟进程退出类似，线程退出时也需要主线程进行等待，这里等待的内容主要是“子线程的返回内容”

// 1.不需要返回值！

// ThreadFunc中
pthread_exit(nullptr);

// main中
pthread_join(tid, nullptr);

// 2.需要接收返回值

// ThreadFunc中
pthread_exit((void*)"hello thread");    // 返回值为hello world

// main中
void *ret = nullptr;
pthread_join(tid, &ret);    // 通过指针来接收这个返回值，原理涉及二级指针

 这里对应着线程等待的两种情况，一旦我们使用了pthread_join那么主线程就会进入阻塞等待。而在第一种情况中并不需要我们进行返回值的接收，这时的等待是不必要的！

因此pthread库中实现了线程分离的接口，这个接口主要是适配当我们不需要关心子线程返回值时，又不想对子线程进行等待，我们可以直接分离这个线程，

// 线程是可以设置为分离状态，主线程不用对新线程进行等待
// 可以是主线程对子线程进行分离
// 在main中分离线程
pthread_detach(tid);

// 不过大部分情况下，我们一般在子进程自己的函数块中分离线程
// 也可子线程对自己进行分离，但是写在这里最好
pthread_detach(pthread_self());

 而线程取消接口主要是正常终止掉我们创建的某个线程

// 线程是可以取消的---相当于之间终止该线程
pthread_cancel(tid);

// cancle后通过pthread_join接收该进程的返回值，会返回-1

2.3.pthread库的原理

在Linux操作系统中，并没有线程的概念。我们这里所讲的线程是用户级线程，是通过pthread库来实现的。所以我们在用户层需要对线程进行管理，在Pthread库中我们也需要定义struct TCB这一个结构，来实现先描述再组织！

既然要实现线程控制块，那么我们就需要定义“栈空间”和“寄存器”这些独立的属性，寄存器模块pthread库可以复用进程中维护的寄存器模块，但是栈空间这个模块我们该如何抽象并实现呢？ 

背景：首先对于单个进程，只有一个地址空间也就只能开辟出一块栈空间，那么从进程中获取栈空间显然是不合理的。所以我们通过进程来实现线程的栈空间这个方向是无法实现的，我们在之前的学习中，对于用户级别的缓冲区，本身也是一块空间，而这块缓冲区的实现是通过C库的，那么我们也可以通过pthread库来实现这一块栈空间。

clone(int (*child_func)(void *),     // 调用的函数
           void *child_stack,        // 开辟的栈空间
           int flags,                // 创建方式
           void *arg, ...            // 传入参数
          /* pid_t *ptid, struct user_desc *tls, pid_t *ctid */ );

这个接口是Linux操作系统实现线程的底层系统调用，也是pthread_create的底层实现，因此我们知道通过库来实现这个栈空间是可行的！ 

我们知道动态库是需要加载进物理内存，并且映射进地址空间，当我们创建一个新线程，就可以把维护的栈空间加载进内存中， 而进程原本的栈空间就是主线程的空间了。

并且当我们动态库加载进物理内存后，而库本身就是pthread实现的代码，当我们在创建线程时，我们从正文代码段跳转到动态库中，运行线程的创建“代码”，那么我们进行线程的管理也是通过动态库的资源（代码）即：进程读取映射进进程地址空间内的动态库的代码，创建数据结构

这时我们也明白了，为什么线程的pthread_t和Linux中的LWP在数值上并不相等！前者是库级别的概念，后者是操作系统的概念。 

2.4.语言和pthread库的关系

我们上面讲述了Linux环境下pthread的实现原理，那么对于C++、Java语言他们内置实现的多线程模块，有什么关系呢。这里我们以c++的thread为例

#include<iostream>
#include<thread>
#include<unistd.h>
#include<cstdlib>

using namespace std;

void ThreadFunc()
{
    while(1)
    {
        cout<< "i am a thread from C++" <<endl;
        sleep(1);
    }
}

int main()
{
    thread t(ThreadFunc);
    t.join();
}

接着我们在Linux环境中编译这个文件： 

1. 当我们第一次编译并运行时（即为绿框内容），我们发现程序无法运行，并且报错为：程序运行在一个不支持多线程或者多线程被禁用的环境中。但是我们明明包括了C++中提供的线程库！
2. 但是当我们链接上了Linux提供的动态库时，这个程序又可以正常运行！

 看到这里大家应该明白了：纯C++的接口创造线程时，也是需要Linux的pthread库，本质上就是C++的标准就是对pthread库的封装！即不同的语言实现多线程的本质就是对不同系统实现的多线程的实现进行封装！比如我们在STL容器中实现的Swap函数，内部是通过封装std中swap函数来实现的！这样就实现了语言代码的可移植性！

2.5.线程局部存储

我们在2.3.中的图看到了线程的属性集中维护了一个线程的局部存储模块，这个模块的作用是，设定同一个变量能给不同的线程维护一个各自独立的值。

int g_val = 100;
__thread int t_val = 0;
void *ThreadFunc(void *arg)
{
    while (1)
    {
        g_val += 10;
        t_val--;
        cout << "new thread g_val = " << g_val << ", t_val = " << t_val << endl;
        sleep(2);
    }
}
// 线程的局部存储
void test7()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, ThreadFunc, (void*)nullptr);

    while(1)
    {
        t_val++;
        g_val = 0;
        cout << "main thread g_val = " << g_val << ", t_val = " << t_val << endl;
        sleep(2);
        cout<<endl;
    }
}

这段代码中我们定义了一个全局变量g_val和对于线程的__thread的t_val，然后我们各自对g_val和t_val进行修改

通过程序的运行结果：我们发现g_val用的是同一块空间，而t_val用的是不同的空间，那么由于__thread这个关键字，编译器编译时会把这个变量分别加载到线程的局部存储区，也就是同一个变量，在不同的空间维护着，不同的线程可以有独立的t_val，这也就是线程LWP的实现原理……