Linux多线程

全文目录

• 线程概念
• • 线程缺点
  • 线程的如何看待进程内部的资源
  • 进程vs线程
• 线程控制
• • pthread库
  • pthread_t
  • 线程创建
  • 线程等待
  • 线程分离
  • 线程退出
  • 总结
• 线程互斥
• • 互斥量接口
  • 互斥量实现原理
  • 总结
• 线程安全与可重入
• • 常见的线程安全的情况
  • 常见的不可重入情况
  • 常见的可重入情况
  • 可重入与线程安全联系
  • 可重入与线程安全区别
• 死锁
• • 死锁四个必要条件
  • 避免死锁
• 线程同步
• • 条件变量初始化与销毁
  • 等待与唤醒
• 生产者消费者模型
• POSIX信号量
• 线程池
• 单例模式的线程安全问题
• 读者写者问题
• • 读写锁
• 线程安全总结

线程概念

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

一个地址空间称为一个程序，至少被一个PCB指向，每个PCB都叫做一个线程，在Linux下线程没有特定的数据结构，进程和线程都是被task_struct描述，但是在Windows下有特定的数据结构。

• 一切进程至少都有一个执行线程
• 线程在进程内部运行，本质是在进程地址空间内运行
• 在Linux系统中，在CPU眼中，看到的PCB都要比传统的进程更加轻量化，统一称之为轻量级进程

Linux中没有真正意义上的线程，是通过进程PCB数据结构来模拟线程的数据结构，素以Linux线程也叫做用户级线程

• 透过进程虚拟地址空间，可以看到进程的大部分资源（包括页表），将进程资源合理分配给每个执行流，就形成了线程执行流

线程缺点

线程的如何看待进程内部的资源

• 线程独享的资源

• 线程ID
• 一组寄存器（上下文数据）
• 栈（函数调用）
• errno
• 信号屏蔽字
• 调度优先级

进程的多个线程共享 同一地址空间，因此Text Segment、Data Segment都是共享的，如果定义一个函数，在各线程中都可以调用，如果定义一个全局变量，在各线程中都可以访问到，除此之外，各线程还共享以下进程资源和环境:

• 文件描述符表
• 每种信号的处理方式(SIG_IGN、SIG_DFL或者自定义的信号处理函数)
• 当前工作目录
• 用户id和组id

进程vs线程

为什么说线程切换的成本比进程切换的成本更低？

• 进程切换虚拟地址需要切换，线程不需要
• 进程切换需要重新加载CPU缓存，线程不用

线程控制

pthread库

因为Linux中没有线程数据结构，所以并没有直接提供现成相关的接口，只提供了轻量化进程的接口，所以在用户层封装了一套线程库 —— pthread库 —— 原生线程库。

在使用的时候需要在包含头文件的基础上加上编译选项：

#include <pthread.h> 		# 头文件包含

-pthread 		# 编译选项

ps -aL  	# 查看线程系统中的线程的命令
1
2
3
4
5

C++中虽然有语言上的库thread，但是底层还是通过pthread库实现的，还是要加上编译选项。

pthread_t

通过打印pthread_t 类型的变量，pthread_t类型的线程ID，本质就是一个进程地址空间上的一个地址。

由于每个线程拥有独立的栈空间，但是又不能在地址空间对每个线程创建独立的栈空间，因为OS中是没有线程概念的，所以独立的栈空间只能由用户层来维护，也就是在pthread库中以结构体的形式来描述并组织。

所以pthread_t 就是对应线程的结构体的起始地址。

每个新线程所谓的独立栈空间就是在共享区通过pthread库维护的数据结构来代替的，主线程使用的则是内核级的栈空间

线程的局部存储：

通过__thread修饰的全局变量可以让共享的全局变量，变成每个线程独有的。

每个线程都可以通过函数获取自身的线程ID：

pthread_self();
1

线程创建

线程等待

为什么需要等待线程退出：

• 已经退出的线程，其空间没有被释放，仍然在进程的地址空间内。
• 创建新的线程不会复用刚才退出线程的地址空间。

线程分离

如果不关心线程的返回值，join是一种负担，这个时候，我们可以告诉系统，当线程退出时，自动释放线程资源。

int pthread_detach(pthread_t thread);
1

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

pthread_detach(pthread_self());
1

joinable和分离是冲突的，即分离之后，不能再进行线程等待。

线程退出

不能直接使用exit 函数退出，exit 是进程退出的函数。

新线程内部退出：

主线程取消新线程：

总结

1. 新线程与主线程谁先运行与调度器有关
2. 线程一旦异常，整个进程都有可能退出（所有线程都是与进程使用同一个标志异常的寄存器）
3. 线程在创建并执行的时候，线程也是需要等待的，如果主线程不等待，会引发类似僵尸进程的问题，导致内存泄漏

线程互斥

相关概念：

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

很多变量都需要在线程间共享，这样的变量称为共享变量，可以通过数据的共享，完成线程之间的交互。多个线程并发的操作共享变量，会带来一些问题。

一行代码在底层可能需要分多步来执行，比如对一个变量进行 -- 操作 ticket-- ：

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

load ：将共享变量ticket从内存加载到寄存器中
update : 更新寄存器里面的值，执行-1操作
store：将新值，从寄存器写回共享变量ticket的内存地

线程运行到任何一步时都有可能会被调度器调度，其上下文数据也会被带走，如果其他线程修改了该变量，就会导致下次回归的线程，同一个变量数据不一致问题。

解决方案：

• 代码必须要有互斥行为：当代码进入临界区执行时，不允许其他线程进入该临界区。
• 如果多个线程同时要求执行临界区的代码，并且临界区没有线程在执行，那么只能允许一个线程进入该临界区。
• 如果线程不在临界区中执行，那么该线程不能阻止其他线程进入临界区。

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

互斥量接口

初始化互斥量：

• 静态分配:

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
1

• 动态分配：

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

返回值：
	成功返回0，失败返回错误码
1
2
3
4
5
6
7
8
9

销毁互斥量：

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

int pthread_mutex_destroy(pthread_mutex_t *mutex)；

返回值：
	成功返回0，失败返回错误码
1
2
3
4

互斥量加锁和解锁：

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

调用pthread_lock 时，可能会遇到以下情况：

• 互斥量处于未锁状态，该函数会将互斥量锁定，同时返回成功
• 发起函数调用时，其他线程已经锁定互斥量，或者存在其他线程同时申请互斥量，但没有竞争到互斥量， 那么pthread_lock调用会陷入阻塞(执行流被挂起)，等待互斥量解锁。对于没有申请到互斥量的线程来说，正在访问临界资源的线程的行为是原子性的。

互斥量实现原理

CPU上的寄存器空间是被所有执行流共享的，但是寄存器的内容是执行流私有的，也就是执行流的上下文数据。

站在汇编的角度上，只有一条汇编语句的指令，就是原子性的。

swap或exchange指令，该指令的作用是把寄存器和内存单元的数据相交换，由于只有一条指令，保证了原子性，即使是多处理器平台，访问内存的 总线周期也有先后，一个处理器上的交换指令执行时另一个处理器的交换指令只能等待总线周期。

lock 和 unlock的伪代码：

通过xchgb命令，线程的上下文数据拿到了锁的内容，也就是共享资源变成了线程的私有资源，就表示申请锁成功。

总结

• 加锁之后，对临界区代码的执行就是串行的（一次只能有一个执行流）

• 线程加锁之后再临界区中执行代码，也会被切换，但是因为其他线程无法申请到互斥量，所以也就无法进入临界区，保证了临界区中数据的一致性

• 多线程申请互斥量，说明需要看到同一个互斥量并且进行竞争，说明互斥量也是临界资源。所以为了保证互斥量的安全，申请和释放锁的行为是原子性的。

线程安全与可重入

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

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

常见的线程安全的情况

• 每个线程对全局变量或者静态变量只有读取的权限，而没有写入的权限，一般来说这些线程是安全的
• 类或者接口对于线程来说都是原子操作
• 多个线程之间的切换不会导致该接口的执行结果存在二义性

常见的不可重入情况

• 调用了malloc/free函数，因为malloc函数是用全局链表来管理堆的
• 调用了标准I/O库函数，标准I/O库的很多实现都以不可重入的方式使用全局数据结构
• 可重入函数体内使用了静态的数据结构

常见的可重入情况

• 不使用全局变量或静态变量
• 不使用用malloc或者new开辟出的空间
• 不调用不可重入函数
• 不返回静态或全局数据，所有数据都有函数的调用者提供
• 使用本地数据，或者通过制作全局数据的本地拷贝来保护全局数据

可重入与线程安全联系

• 函数是可重入的，那就是线程安全的
• 函数是不可重入的，那就不能由多个线程使用，有可能引发线程安全问题
• 如果一个函数中有全局变量，那么这个函数既不是线程安全也不是可重入的。

可重入与线程安全区别

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

死锁

死锁是指在一组进程中的各个进程均占有不会释放的资源，但因互相申请被其他进程所站用不会释放的资源而处于的一种永久等待状态。

成环状地申请对方锁，并不释放自己的锁。

死锁四个必要条件

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

避免死锁

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

线程同步

多线程协作时，访问临界资源，需要先对临界资源进行检测，这也是访问临界资源，临界资源没有就绪，线程可能会频繁进行锁的申请和释放，并对临界资源做检测。这样就导致其他线程访问临界资源的比例下降了，可能会导致整体的效率下降。所以当临界资源不满足时，可以通过条件变量来让线程等待，并通过指定线程控制条件变量来协调多线程对临界资源的访问，提高效率。

条件变量： 控制线程在进行访问某个临界资源时，如果不满足条件只能等待条件满足，否则什么都做不了。

同步： 在保证数据安全的前提下，让线程能够按照某种特定的顺序访问临界资源，从而有效避免饥饿问题，叫做同步。

条件变量是实现同步的关键之一。

条件变量初始化与销毁

• 静态分配

pthread_cond_t cond= PTHREAD_cond_INITIALIZER;
1

• 动态分配

• 销毁条件变量

等待与唤醒

• 等待
  

mutex： 等待是发生在临界资源检测之后，也就是当线程进行等待时就已经申请了锁，
		传入的锁就是为了在调用成功是进行释放锁，防止死锁。
1
2

• 唤醒
  

生产者消费者模型

生产者消费者模式就是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。这个阻塞队列就是用来给生产者和消费者解耦的。

优点：

• 解耦
• 支持并发
• 支持忙闲不均

该模型就能很好解决线程同步问题，生产者进行生产并对消费者访问临界资源进行条件控制，消费者只进行消费同时对生产者对访问临界资源进行条件控制。

效率提高：

生产者或者消费者进行生产或者消费只有一瞬间，但是生产或者消费的动作需要大量的时间，也就提供了线程并发的条件。

POSIX信号量

POSIX信号量相当于临界资源的计数器， 申请等待信号量相当于将计数器- -，信号量不足时，会自动进行阻塞等待， 发布信号量相当于计数器++。 这个特性可用于解决线程同步问题。

线程池

与内存池同原理，预先申请资源，需要用时做到随叫随到。同样的是属于生产者消费者模型。

一般来说是主线程进行生产任务，线程池中的分线程执行任务。

单例模式的线程安全问题

在多线程中设计单例模式，饿汉模式没有线程安全问题，因为单例会在主线程创建之前创建好。

懒汉模式中，如果两个线程同时在第一次获取单例就会引发严重的线程安全问题，所以在多线程中使用懒汉模式需要小心使用：

线程安全版本的懒汉模式：

// 懒汉模式, 线程安全
template <typename T>
class Singleton {
	volatile static T* inst; // 需要设置 volatile 关键字, 否则可能被编译器优化.
	static std::mutex lock;
	public:
	static T* GetInstance() {
		if (inst == NULL) { // 双重判定空指针, 降低锁冲突的概率, 提高性能.
			lock.lock(); // 使用互斥锁, 保证多线程情况下也只调用一次 new.
			if (inst == NULL) {
				inst = new T();
			}
			lock.unlock();
		}
		return inst;
	}
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

读者写者问题

有些公共数据修改的机会比较少。相比较改写，它们读的机会反而高的多。通常而言，在读的过程中，往往伴随着查找的操作，中间耗时很长。给这种代码段加锁，会极大地降低我们程序的效率。

读写锁就是为了解决这种情况的：

读写锁

线程安全总结

1. STL与线程安全问题

STL 的设计初衷是将性能挖掘到极致, 而一旦涉及到加锁保证线程安全, 会对性能造成巨大的影响。

而且对于不同的容器, 加锁方式的不同, 性能可能也不同(例如hash表的锁表和锁桶)。

因此 STL 默认不是线程安全. 如果需要在多线程环境下使用, 往往需要调用者自行保证线程安全.，

2. 智能指针与线程安全问题

对于 unique_ptr, 由于只是在当前代码块范围内生效, 因此不涉及线程安全问题. 对于 shared_ptr,
多个对象需要共用一个引用计数变量, 所以会存在线程安全问题. 但是标准库实现的时候考虑到了这 个问题, 基于$原子操作(CAS)$的方式保证 shared_ptr 能够高效, 原子的操作引用计数。
注意： 如果智能指针与STL配合使用，依然不是线程安全的。