【Linux初阶】多线程2 | 分离线程，线程库，线程互斥，可重入VS线程安全，锁的常见概念

文章目录

• ☀️一、分离线程
• • [🌻1.pthread_ self - 获取线程ID](#🌻1.pthread_ self - 获取线程ID)
  • 🌻2.线程分离
• ☀️二、用户级线程库
• • 🌻1.pthread_t
  • [🌻2.理解用户级线程库 - pthread库](#🌻2.理解用户级线程库 - pthread库)
  • 🌻3.局部存储
• ☀️三、线程互斥
• • 🌻1.线程间的互斥相关概念
  • [🌻2.互斥量 - mutex](#🌻2.互斥量 - mutex)
  • 🌻3.互斥量接口
  • • ⚡（1）初始化互斥量
    • ⚡（2）销毁互斥量
  • 🌻4.互斥量原理探究
• ☀️四、可重入VS线程安全（了解）
• ☀️五、锁的常见概念
• • 🌻1.锁的基础概念
  • 🌻2.死锁（了解）
  • • ⚡（1）死锁四个必要条件
    • ⚡（2）避免死锁
    • ⚡（3）避免死锁算法

---

☀️一、分离线程

🌻1.pthread_ self - 获取线程ID

• pthread_ create函数会产生一个线程ID，存放在第一个参数指向的地址中。该线程ID和前面（上一篇文章）说的线程ID不是一回事。

• 前面讲的线程ID属于进程调度的范畴。因为线程是轻量级进程，是操作系统调度器的最小单位，所以需要一个数值来唯一表示该线程。

• pthread_ create函数第一个参数指向一个虚拟内存单元，该内存单元的地址即为新创建线程的线程ID，属于NPTL线程库的范畴。线程库的后续操作，就是根据该线程ID来操作线程的。

• 线程库NPTL提供了pthread_ self函数，可以获得线程自身的ID：

pthread_t pthread_self(void);

🌻2.线程分离

• 默认情况下，新创建的线程是joinable的，线程退出后，需要对其进行 pthread_join操作（线程等待），否则无法释放资源，从而造成系统泄漏。
• 如果不关心线程的返回值，join是一种负担，这个时候，我们可以告诉系统，当线程退出时，自动释放线程资源，即分离线程操作。

线程分离的代码如下：

int pthread_detach(pthread_t thread);

可以是线程组内其他线程对目标线程进行分离，也可以是线程自己分离:

pthread_detach(pthread_self());

joinable和分离是冲突的，一个线程不能既是joinable又是分离的。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>

void* thread_run(void* arg)
{
	pthread_detach(pthread_self());
	printf("%s\n", (char*)arg);
	return NULL;
}

int main(void)
{
	pthread_t tid;
	if (pthread_create(&tid, NULL, thread_run, "thread1 run...") != 0) {
		printf("create thread error\n");
		return 1;
	}

	int ret = 0;
	pthread_detach(tid);	//我们可以直接在主线程对新线程进行分离
	sleep(1); //也可以让主线程休眠一下，先让新线程分离（我们不知道主线程等待和新线程分离谁先运行，所以sleep1秒）


	if (pthread_join(tid, NULL) == 0) {
		printf("pthread wait success\n");
		ret = 0;
	}
	else {
		printf("pthread wait failed\n");
		ret = 1;
	}

	return ret;
}

运行结果：屏幕输出 - pthread wait failed，即等待失败。
总结：当我们不关心新线程返回值时，可以使用线程分离操作，这样我们就不用对新线程进行等待。

---

☀️二、用户级线程库

🌻1.pthread_t

• pthread_t 到底是什么类型呢？取决于实现。对于Linux目前实现的NPTL实现而言，pthread_t类型的线程ID，本质就是一个进程地址空间上的一个地址。
• 接下来我们会对这部分知识做深入讲解。

🌻2.理解用户级线程库 - pthread库

• 图一：

• 用户需要通过用户级线程库创建新线程，线程库使用的接口为 clone。
• pthread库也被称为原生线程库。
• 创建新线程：库会帮我们创建对应的线程PCB（轻量级进程）、TCB（线程控制块），然后将新线程的数据压到库空间中。

小结：1.用户级线程，用户关心的线程属性在库中，内核提供线程执行流的调度。2.用户级线程：内核轻量级进程 = 1：1。

• 原生线程库中，可能存在多个线程。这些线程也需要我们管理起来。

• 我们通过"先描述，再组织"的方式对新线程进行管理。具体方法我们在后面进行详细讲解。

• 图二：

• 磁盘中保存有 libpthread.so库文件，它对应在地址空间的映射区域为共享区（mmap区域）。

• 图三：
  

• 上图中用蓝色框框住的，就是一个个线程控制块（TCB），我们可以将它们以数组（TCB threads[ ]）的形式排列起来。

• pthread_t tid 就是一个进程控制块的起始地址！

• 通过上图我们可以印证，每个线程都有自己的上下文（局部存储）和栈（线程栈）。

• 新线程栈的位置位于共享区的mmap区域中，即主线程的栈保存在地址空间的栈空间中，新线程的栈保存在共享区中。

先描述：我们通过线程控制块将新线程的数据进行描述。

再组织：就是使用数组的方式将线程的属性信息按需陈列在我们的库当中，再使用地址来标识某个线程，未来用户只要知道某个线程的线程ID（地址），就能对某个线程进行操作了。

🌻3.局部存储

我们可以通过添加__thread，将全局变量设置为线程局部存储。

__thread int g_val = 100

• 设置为局部存储之后，这个变量依旧为全局变量，但是它会在每个线程中都保存一份。
• 在新线程中对该变量做修改，不会影响主线程该变量对应的值。
• 该变量在新线程中会被保存在它的私有栈中，即共享区中。

---

☀️三、线程互斥

🌻1.线程间的互斥相关概念

• 临界资源：多线程执行流共享的资源就叫做临界资源。
• 临界区：每个线程内部，访问临界资源的代码，就叫做临界区。
• 互斥：任何时刻，互斥保证有且只有一个执行流进入临界区，访问临界资源，通常对临界资源起保护作用。
• 原子性（后面讨论如何实现）：不会被任何调度机制打断的操作，该操作只有两态，要么完成，要么未完成。

🌻2.互斥量 - mutex

• 大部分情况，线程使用的数据都是局部变量，变量的地址空间在线程栈空间内，这种情况，变量归属单个线程，其他线程无法获得这种变量。
• 但有时候，很多变量都需要在线程间共享，这样的变量称为共享变量，可以通过数据的共享，完成线程之间的交互。
• 多个线程并发的操作共享变量，会带来一些问题。

// 操作共享变量会有问题的售票系统代码
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>

int ticket = 100;

void* route(void* arg)
{
	char* id = (char*)arg;
	while (1) {
		if (ticket > 0) {
			usleep(1000);
			printf("%s sells ticket:%d\n", id, ticket);
			ticket--;
		}
		else {
			break;
		}
	}
}

int main(void)
{
	pthread_t t1, t2, t3, t4;
	pthread_create(&t1, NULL, route, "thread 1");
	pthread_create(&t2, NULL, route, "thread 2");
	pthread_create(&t3, NULL, route, "thread 3");
	pthread_create(&t4, NULL, route, "thread 4");
	pthread_join(t1, NULL);
	pthread_join(t2, NULL);
	pthread_join(t3, NULL);
	pthread_join(t4, NULL);
}

一次执行结果：
thread 4 sells ticket : 100
...
thread 4 sells ticket : 1
thread 2 sells ticket : 0
thread 1 sells ticket : -1
thread 3 sells ticket : -2

• 正常来说ticket为0就应该已经结束才对，为什么没有输出正确结果呢？

• if 语句判断条件为真以后，代码可以并发的切换到其他线程。

• usleep 这个模拟漫长业务的过程，在这个漫长的业务过程中，可能有很多个线程会进入该代码段。

• --ticket 操作本身就不是一个原子操作。

取出ticket--部分的汇编代码
objdump -d a.out > test.objdump
152 40064b: 8b 05 e3 04 20 00 mov 0x2004e3(%rip),%eax # 600b34 <ticket>
153 400651: 83 e8 01 sub $0x1,%eax
154 400654: 89 05 da 04 20 00 mov %eax,0x2004da(%rip) # 600b34 <ticket>

• -- 操作并不是原子操作，而是对应三条汇编指令：

• load ：将共享变量ticket从内存加载到寄存器中。

• update : 更新寄存器里面的值，执行-1操作。

• store ：将新值，从寄存器写回共享变量ticket的内存地址。

• 由此可见，原子性的代码编译之后应该只有一条汇编指令。

当多个线程同时对某个临界资源进行操作、读取、判断，就可能会出现内存数据不一致的问题。依旧用上面的代码举例，你线程A已经将值减到0，此时另一线程B已经处于判断完的阶段，线程B会继续--，导致最后出现-1。
多线程交替执行还可能造成下面的问题：可能线程A刚完成第二步，我们在这里假设它--到了99，线程A的时间片到了，线程A被剥离，线程A在被操作系统剥离时会将CUP寄存器中的值也带走，而后换上线程B进行执行。线程B--到了20，并将这个值写回了内存，此时它的时间片也到了，重新换上线程A执行。此时线程A会恢复寄存器中的值（99），并执行第三步，将这个值加载到内存，此时内存中线程共有的 ticket值就被覆盖了（20->99），从而影响线程的下一次判断。
我们定义的全局变量，在没有保护的时候，往往是不安全的，像上面那样多个线程交替式执行，会造成数据不一致问题。

• 要解决以上问题，需要做到三点：

• 代码必须要有互斥行为：当代码进入临界区执行时，不允许其他线程进入该临界区。

• 如果多个线程同时要求执行临界区的代码，并且临界区没有线程在执行，那么只能允许一个线程进入该临界区。

• 如果线程不在临界区中执行，那么该线程不能阻止其他线程进入临界区。

要做到这三点，本质上就是需要一把锁。Linux上提供的这把锁叫互斥量。

🌻3.互斥量接口

⚡（1）初始化互斥量

初始化互斥量有两种方法：

• 方法1，静态分配：

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER

注意：静态分配互斥量即在全局中进行分配，静态分配之后不需在进行 init动态分配和 destroy销毁。

• 方法2，动态分配：

int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict
attr);
参数：
	mutex：要初始化的互斥量
	attr：NULL

⚡（2）销毁互斥量

销毁互斥量需要注意：

• 使用 PTHREAD_ MUTEX_ INITIALIZER 初始化的互斥量不需要销毁。
• 不要销毁一个已经加锁的互斥量。
• 已经销毁的互斥量，要确保后面不会有线程再尝试加锁。

销毁互斥代码如下：

int pthread_mutex_destroy(pthread_mutex_t *mutex)；

互斥量加锁和解锁：

int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
返回值:成功返回0,失败返回错误号

调用 pthread_mutex_lock 进行加锁时，可能会遇到以下情况:

• 互斥量处于未锁状态，该函数会将互斥量锁定，同时返回成功（成功加锁）。
• 发起函数调用时，其他线程已经锁定互斥量，或者存在其他线程同时申请互斥量，但没有竞争到互斥量，那pthread_mutex_lock调用会陷入阻塞(执行流被挂起)，等待互斥量解锁（加锁失败，线程阻塞）。

改进上面的售票系统：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <sched.h>

int ticket = 100;
pthread_mutex_t mutex;

void* route(void* arg)
{
	char* id = (char*)arg;
	while (1) 
	{
		pthread_mutex_lock(&mutex);
		if (ticket > 0) 
		{
			usleep(1000);
			printf("%s sells ticket:%d\n", id, ticket);
			ticket--;
			pthread_mutex_unlock(&mutex);

		}
		else {
			pthread_mutex_unlock(&mutex);
			break;
		}
	}
}

int main(void)
{
	pthread_t t1, t2, t3, t4;

	pthread_mutex_init(&mutex, NULL);

	pthread_create(&t1, NULL, route, "thread 1");
	pthread_create(&t2, NULL, route, "thread 2");
	pthread_create(&t3, NULL, route, "thread 3");
	pthread_create(&t4, NULL, route, "thread 4");

	pthread_join(t1, NULL);
	pthread_join(t2, NULL);
	pthread_join(t3, NULL);
	pthread_join(t4, NULL);

	pthread_mutex_destroy(&mutex);
}

一次执行结果：
thread 4 sells ticket : 100
...
thread 3 sells ticket : 1
thread 3 sells ticket : 0

总结：加锁之后，可让线程进行串形执行。

🌻4.互斥量原理探究

• 经过上面的例子，大家已经意识到单纯的 i++ 或者++i都不是原子的，有可能会有数据一致性问题。
• 为了实现互斥锁操作，大多数体系结构都提供了swap或exchange指令（如下面代码 xchgb），该指令的作用是把寄存器和内存单元的数据相交换，由于只有一条指令，保证了原子性，即使是多处理器平台，访问内存的总线周期也有先后，一个处理器上的交换指令执行时另一个处理器的交换指令只能等待总线周期。
• 现在我们把lock和unlock的伪代码表述一下

加锁理解：

• 假设有线程A、B两个线程。
• 线程A将0加载到 %al寄存器中。
• 内存中有一空间专门存储 mutex变量，mutex变量默认为1，代表锁未被申请。xchgb将寄存器中的值和内存中的mutex进行交换。
• 如果al寄存器中的值大于0，则返回并执行相应的内容代码，否则就将线程挂起。
• 如果线程A在使用锁，在线程A时间片到了被剥离下来的时候它会将寄存器中的值也带走。
• 线程B进入该代码逻辑后，从内存中交换到al寄存器寄存器中的值等于0，经过判断，最终被挂起。

解锁理解：

• 将al寄存器中的值重新 movb回内存中，将释放锁（将mutex恢复为默认值）。

---

☀️四、可重入VS线程安全（了解）

• 概念

• 线程安全：多个线程并发同一段代码时，不会出现不同的结果。常见对全局变量或者静态变量进行操作，并且没有锁保护的情况下，就会出现线程不安全问题。

• 重入：同一个函数被不同的执行流调用，当前一个流程还没有执行完，就有其他的执行流再次进入，我们称之为重入。一个函数在重入的情况下，运行结果不会出现任何不同或者任何问题，则该函数被称为可重入函数，否则，是不可重入函数。

• 常见的线程安全的情况

• 每个线程对全局变量或者静态变量只有读取的权限，而没有写入的权限，一般来说这些线程是安全的

• 类或者接口对于线程来说都是原子操作

• 多个线程之间的切换不会导致该接口的执行结果存在二义性

• 常见的线程不安全的情况

• 不保护共享变量的函数

• 函数状态随着被调用，状态发生变化的函数

• 返回指向静态变量指针的函数

• 调用线程不安全函数的函数

• 常见可重入的情况

• 不使用全局变量或静态变量

• 不使用用malloc或者new开辟出的空间

• 不调用不可重入函数

• 不返回静态或全局数据，所有数据都有函数的调用者提供

• 使用本地数据，或者通过制作全局数据的本地拷贝来保护全局数据

• 常见不可重入的情况

• 调用了malloc/free函数，因为malloc函数是用全局链表来管理堆的

• 调用了标准I/O库函数，标准I/O库的很多实现都以不可重入的方式使用全局数据结构

• 可重入函数体内使用了静态的数据结构

• 可重入与线程安全区别

• 可重入函数是线程安全函数的一种线程安全不一定是可重入的，而可重入函数则一定是线程安全的。

• 如果将对临界资源的访问加上锁，则这个函数是线程安全的，但如果这个重入函数若锁还未释放则会产生死锁，因此是不可重入的。

---

☀️五、锁的常见概念

🌻1.锁的基础概念

• 锁在Linux下是互斥量的别称，用于保护临界区资源，使临界区资源只能由线程串行访问。

• 加锁和解锁的过程是由多个线程串行执行的，即使某个线程的时间片到了，被剥离下来也是带着锁的，其他线程不能执行锁中间的代码（锁其实是原子的）。

• 使用锁会导致程序的运行速度会变慢。

• 锁只规定互斥访问，没有规定那个线程优先执行。

• 锁在多线程中是需要多个线程进行竞争的。

• 未来我们在使用锁的时候，一定要保证临界区的粒度（锁中间代码量）要非常小！

• 加锁成功函数会返回特定的值，失败会导致线程阻塞、被挂起（锁正在被占用）。

🌻2.死锁（了解）

• 死锁是指在一组进程中的各个进程均占有不会释放的资源，但因互相申请被其他进程所占用不会释放的资源而处于的一种永久等待状态。
• 简单来说，就是在多把锁的情况下，我们持有自己的锁不释放，还要去申请对方的锁，对方也是如此，最终大家都在永久等待，造成死锁。、
• 一把锁也可能造成死锁（代码写错了，一把锁申请两次）。
• 任何技术都是有边界的，技术在解决某些问题的同时往往会引入新的问题。

⚡（1）死锁四个必要条件

• 互斥条件：一个资源每次只能被一个执行流使用
• 请求与保持条件：一个执行流因请求资源而阻塞时，对已获得的资源保持不放
• 不剥夺条件：一个执行流已获得的资源，在末使用完之前，不能强行剥夺
• 循环等待条件：若干执行流之间形成一种头尾相接的循环等待资源的关系

⚡（2）避免死锁

• 破坏死锁的四个必要条件
• 加锁顺序一致
• 避免锁未释放的场景
• 资源一次性分配

⚡（3）避免死锁算法

• 死锁检测算法(了解)
• 银行家算法（了解）