Linux线程相关知识总结

Linux系统下的线程

概述：

首先我们必须先明确Linux系统下没有真正的线程，因为Linux下的线程是以进程的PCB模拟实现的。所以说Linux下的线程也叫轻量级进程。（我在多个系统下看到，它们各自有各自的名字）

• 那我们这里就先明确一下，以前说的PCB进程实际上是是一个单线程的进程。而真正的进程实际上是多个线程组成的线程组。

• 那么问题来了，我们在Linux系统下通过ps -ef命令查看进程信息，明明看到一个进程的PID是一个没有重复的数字，按照我们刚才的说法，应该一个多线程进程的PID应该是不同的才对呀。

• 是这样的，我们外部看到的pid，实际上就是task_struct结构体中的tgid，而真正的PID在外部看到的是LWP。使用的命令是ps -efL

• 一个程序运行起来，一开始会创建一个PCB，这个PCB有一个PID，也有一个tgid。并且这个tgid就等于PID的值。如果创建了新的PCB，那么这些PCB中的tgid都是一样的。

• CPU调度进程是以PCB调度的，而Linux下的PCB是线程，因此我们得出线程是CPU调度的基本单位。

• 那么就可以得出结论：线程是在进程的虚拟空间中运行。

对比一下线程和进程

• 优点：因为多个线程共享虚拟地址空间

  1.因此创建/销毁一个线程的成本更低(创建一个进程要创建无数个表去维护这个进程)

  2.因此线程之间的调度与切换成本更低(毕竟在一个虚拟空间中，很多东西都是共享的)

  3.因此线程之间的通信更加方便（之前说的进程还要管道，共享内存。而线程组就在统一媒介上）

• 缺点：

  1.缺乏访问控制(逻辑控制复杂，经常需要和主程序交互)

  2.稳定性变低（如果exit直接就退出进程，容易发生段错误。或者一个线程出异常，可能整个进程都会退出）

• 那么到底进程好还是线程好？

  分析利弊，根据使用场景而定

线程间数据的共享和独有：

• 共享：

  1.文件描述符表，代表一个线程中打开文件，另一个线程拿着文件描述符就可以直接对文件操作

  2.信号的处理方式

  3.当前工作目录和用户id和组id

• 独有：

  1.标识符

  2.栈区（每一个线程都有自己的调用栈，这个栈区是虚拟地址空间划分出的栈区，而这个独有是相对独有，因为他们可以互相访问，只是有一定的限制）

  3.上下文数据和程序计数器

  4.errno（好比两个线程，A和B，A出错把errno置为错误，再打印前，B又没错所以把errno又置为正确，导致打印出来的A也是正确的）

  5.信号屏蔽字

  6.调度优先级

多线程的应用场景：

• 多用于IO密集型程序/CPU密集型程序

• IO密集型：程序里多数都在读写IO操作，如果单线程，需要等待的时间太久，而多线程，就可以同一时间几十个线程，同时写入，读取

• CPU密集型：大量计算，当CPU抗压的情况下，一起计算。

• 作用：分摊压力，提高效率

线程的创建：

操作系统并没直接提供线程控制的相关接口，因此就有人封装了一套线程控制的接口，所以线程的创建这里我们用的都是库函数，并且我们创建出的线程都是用户态的线程，这个用户态线程在操作系统中对应了一个轻量级进程

接口函数

int pthread_create(pthread_t *thread, const pthread_attr_t *attr,void *(*start_routine) (void *), void *arg);
//pthread_t *thread---用于获取用户态线程id
//const pthread_attr_t *attr---设置线程属性，通常设NULL
//void *(*start_routine) (void *)---线程的入口函数（main函数就是进程中第一个线程的入口函数）
//void *arg---这个参数就传给上面的void *(*start_routine) (void *)

• 返回值：成功返回0，失败返回非0—错误编号

• 每一个线程在虚拟地址空间中都有一份自己独有的线程地址空间存储自己的数据

• 用户态的线程id，实际上是一个虚拟地址空间中的地址，线程地址空间的首地址（我们这里叫TID）

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>
void* thr_start(void* arg)
{
     while(1) {
              printf("宝宝是创建出来的新线程\n");
                       sleep(1);
     }
     return NULL;
 }
 int main()
 {
     pthread_t tid;
     int ret = pthread_create(&tid, NULL, thr_start, NULL);
     if (ret != 0) {
         printf("create pthread error\n");
         return -1;
   }
     while(1)
      {
         printf("我是主线程， cthread id:%p\n", tid);
         sleep(1);
     }
     return 0;
 }

线程的终止：

• 首先我们要明确线程的终止是不讨论异常退出的，因为异常退出，整个进程都退出了

• 1.在线程中使用return 退出，但是主线程中，不能return退出，因为main函数中退出等价于exit，就等于退出了整个进程

• 2.接口函数

void pthread_exit(void *retval);
//void *retval---这是用于接收线程退出的返回值

• 返回值：没有返回值

• 需要注意的是一般都是退出线程自己，大多数是线程的主动行为

• 退出一个线程，主线程退出进程不一定退出，因为还要看看进程中还有没有别的线程

int pthread_cancel(pthread_t thread);
//pthread_t thread)---就是要退出线程的TID

• 返回值：成功返回0，失败返回错误码

• 这个接口就是指定线程杀死哪一个线程

• 但是如果这个接口杀死的是主线程，子线程的状态依赖于它所在的进程，如果进程没有退出的话子线程依然正常运转。如果进程退出了，那么它所有的线程都会退出

• 那么有一个好玩的！！嘻嘻，自杀怎么办?线程如何获取自己的TID呢？

pthread_t pthread_self(void);
void---没有参数

• 返回值：返回调用线程的id

pthread_cancel(pthread_t pthread_self());

• 自杀函数

• 尽量不要取消自己，因为没啥意义

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>
 
void *thr_start(void *arg)
 {
     while(1)
     {
         printf("求求你不要干掉我qvq!qvq!qvq!\n");
         sleep(1);
     }
     return NULL;
 }
 int main()
 {
     pthread_t tid;
     int ret = pthread_create(&tid, NULL, thr_start, (void*)55);
     if (ret != 0)
     {
	 printf("create thread error\n");
         return -1;
     }
     sleep(3);
     pthread_cancel(tid);
     while(1)
     {
         printf("皮?\n");
         sleep(1);
     }
     return 0;
 }

线程的等待：

• 我们看一下线程退出的函数int pthread_cancel(pthread_t thread);知线程退出以后也要保存自己的退出返回值，因此线程也需要被等待

• 那么线程退出以后，主线程或者其他线程也会获取线程退出返回值，并且允许操作系统回收资源

• 但是也只有线程处于joinable状态的时候，这个线程的退出才可以被等待（joinable是线程的默认属性）

• joinable状态的线程如果退出，需要被等待，获取返回值，并且允许操作系统回收资源

int pthread_join(pthread_t thread, void **retval);
//pthread_t thread---需要等待线程的ID
//void **retval---用于接收线程退出的返回值

• 返回值：成功返回0，失败返回一个编号

• 这个函数是将线程挂起等待，等待到id为thread的线程终止，该线程以不同的方式终止，得到的函数的终止状态是不同的

• 而我们刚才讲到线程是会被取消的，即使线程被取消，也要被等待，并且返回值是-1

线程的分离：

• 但是如果我们完全不关心线程的退，更不会去关心其返回值，那么就可以将线程和线程组的其他线程进行分离，这样线程退出时，会自动释放资源

int pthread_detach(pthread_t thread);
//需要分离线程的ID

• 返回值：成功返回，失败返回错误编号

• 分离指定线程，不分位置，只要知道需要分离现成的ID就可以分离

• 但是分离前必须设置线程属性从joinable切换为detach状态

• 线程的状态只能是joinable和detach状态之一

• detach状态的线程，无法被等待，如果强行等待直接报错返回，因为等不到东西

线程安全：

• 专业术语：多个线程执行流对共享资源的不安全争夺操作，怎么解释这句话呢，线程之间也存在着对临界资源的争夺，那么在争夺的时候，就会发生线程的安全事故，所以就要考虑到线程的安全

• 实现：线程之间安全的对临界资源进行操作主要依靠的就是同步与互斥

• 互斥：同一时间临界资源的唯一访问性

• 那么这里就引入了互斥锁/互斥量的概念

• 什么是互斥锁/互斥量

  一个整形变量，但是不同的是他只有0和1，两个状态。所以我们也可以理解他是一个状态变量

  互斥量是一个共享变量，因此他对每一个需要临界资源的线程，都具有上锁与开锁的限制(0为开锁，1为上锁)

• 先去定义一个互斥锁，在访问资源前，先去访问资源锁，如果资源没有被人使用，那么他先上一个锁，访问完再解锁，所以这里存在阻塞。让其他线程排队访问，实际上互斥锁就是一个计数器，但是这个计数器的值只有0或者1

• 画一个流程图，理解一下这个过程

• 但是互斥锁也是一个临界资源，那么怎么保证他的安全？就意味着，互斥锁的操作，必须是原子操作。

• 接下来我们就看看互斥锁pthread_mutex_t mutex及其他的家族函数

• 互斥锁操作步骤：

//第一步：定义互斥锁变量pthread_mutex_t  mutex
//第二步：初始化互斥锁变量
	int pthread_mutex_init(pthread_mutex_t *restrict mutex,const pthread_mutexattr_t *restrict attr);
	//pthread_mutex_t *restrict mutex---需要初始化的互斥锁
	//const pthread_mutexattr_t *restrict attr---互斥锁属性，通常设置为NULL
	//还一种方法比较直接，一个宏一句搞定
	pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER；
//第三步：临界操作前加锁
	int pthread_mutex_lock(pthread_mutex_t *mutex);
	int pthread_mutex_trylock(pthread_mutex_t *mutex);
	//不一样的是当锁已经在使用的时候，返回为EBUSY，而不是挂起等待。
//第四步：临界操作完毕解锁
	int pthread_mutex_unlock(pthread_mutex_t *mutex);
//第五步：销毁互斥锁
	int pthread_mutex_destroy(pthread_mutex_t *mutex);

• 加锁之后要在线程任意可能退出的位置都要解锁

• 这里就引入了一个可能性：死锁

• 先说死锁产生的四个必要条件：

  1.互斥条件

  2.不可剥夺条件

  3.请求与保持条件

  4.环路等待条件

• 画个图理解一下死锁

• 预防死锁：破坏其中一个条件，预防条件3和条件4，注意枷锁的顺序必须保持一致。

• 避免死锁：银行家算法，死锁检测算法

• 同步：对临界资源操作的一个时许可控性

• 当线程互斥的访问某个变量时，它可能发现其他线程改变状态之前，他什么也做不了

• 条件变量：只有两个功能，等待，唤醒

• 这里我们举一个非常不恰当的例子来描述一下我们将要讲述的内容。

老王是一个老师，小美是一个学生。老王对班级同学要求十分严格，要求他们必须完成他们的家庭作业。就会有两种情况发生，老王布置了作业，通知小美写作业。小美写完作业了，然后告诉老王，我写完了，然后他就翻墙去网吧吃鸡去了。那么对应到我们这里，老王就是线程A，小美就是线程B，作业就是临界资源。线程B，需要完成的必须是线程A修改过的变量(小美只能写老王布置的数学作业，英语作业老王也看不懂)，当线程A修改完变量的值后，会发出一个信号告知线程B，变量就绪，然后线程B去访问这个变量(老王布置了作业，然后告诉小美该写作业了)。第二种情况对应过来就是，线程B需要访问变量，可是线程A还没有提供，那么他会给线程A发一个信号，告诉线程A，需要变量(对应过来就是，小美让老王赶紧把家庭作业布置了，我着急写完吃鸡呢)

• 不难发现这里是一个类似队列的数据结构，因为条件变量在未达到需要的时候，线程必须等待。直到条件变量满足需要，等待的过程，就发生在队列中

//第一步：定义条件变量pthread_cond_t cond

//第二步：条件变量的初始化
int pthread_cond_init(pthread_cond_t *restrict cond,const pthread_condattr_t *restrict attr);
//pthread_cond_t *restrict cond---需要初始化的条件变量
//const pthread_condattr_t *restrict attr---设置条件变量的属性，通常设置为NULL
//同样有一个宏一步到位pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
//第三步：等待一个满足条件的变量
int pthread_cond_wait(pthread_cond_t *restrict cond,pthread_mutex_t *restrict mutex);
int pthread_cond_timedwait(pthread_cond_t *restrict cond,pthread_mutex_t *restrict mutex,const struct timespec *restrict abstime);
//这里有一个锁，主要是为了满足互斥锁中提到的，要在任意可能位置解锁，完事再上锁
//两个接口不同之处在于，上面的接口，就是死等，死也要等一个满足的，下面的有时间限制
//第四步：等到满足的条件变量了，发送通知
int pthread_cond_broadcast(pthread_cond_t *cond);
int pthread_cond_signal(pthread_cond_t *cond);
//两个接口不同之处在于，上面的广告告知，宛如拿个大喇叭，告诉所有需要的进程。
//下面的只是给需要变量的一个进程发信号
//第五步：销毁条件变量
int pthread_cond_destroy(pthread_cond_t *cond);

生产者与消费者模型

• 可以说这是一个简单的总结，但也引入了新的概念：仓库

• 生产者与消费者模型：一个场所，两类角色，三种关系

• 先讲一个例子，方便我们理解

双11，商品加价再打折，疯狂吸引消费者。哈哈，扎铁不老心。言归正传，最开的人，是淘宝网和天猫。但是赚钱同样需要提供服务，而我们都知道双11的第一分钟，交易量是巨大的，同一时间，可能产生上百万的订单需要处理，而这每一个订单，都可以看作是一个线程处理过的变量，而完成的。阿里需要提供上百万个订单去供消费者使用，而我们不可能创造上百万个线程吧，去制造这些变量吧。那么就需要引入一个仓库，这边线程修改变量，修改完，放进仓库，那边线程需要了，就从仓库中提取。这样就大大减小了需要等待的时间。

• 而一个场所就指的是我们这里的仓库

• 两类角色，生产者(A类修改变量的线程)，消费者(B类使用修改过变量的线程)

• 三种关系，A类线程间的关系(互斥)，B类线程间的关系(互斥)，AB类线程间的关系(互斥及同步)

• 我们画一个图去理解一下