目录
[Part1. 线程基础概念](#Part1. 线程基础概念)
[Part1.1. 线程与进程的区别](#Part1.1. 线程与进程的区别)
[Part1.2. 线程封装信息](#Part1.2. 线程封装信息)
[Part1.3. 线程私有存储](#Part1.3. 线程私有存储)
[Part1.4. 线程名字操作接口](#Part1.4. 线程名字操作接口)
[Part2. 线程资源共享带来的问题](#Part2. 线程资源共享带来的问题)
[Part2.1. 线程切换触发时机](#Part2.1. 线程切换触发时机)
[Part2.2. 锁的引入](#Part2.2. 锁的引入)
[Part3. 互斥锁](#Part3. 互斥锁)
[Part3.1. 初始化函数](#Part3.1. 初始化函数)
[Part3.2. 核心接口](#Part3.2. 核心接口)
[Part3.3. 锁与临界资源](#Part3.3. 锁与临界资源)
[Part3.4. 锁与值传递](#Part3.4. 锁与值传递)
[Part3.5. 互斥锁底层原理](#Part3.5. 互斥锁底层原理)
[Part3.6. 锁运行过程](#Part3.6. 锁运行过程)
[Part3.7. 线程的同步](#Part3.7. 线程的同步)
[Part4. 结语](#Part4. 结语)
前言
Linux下对于线程的了解是非常重要的,接下来来跟随小编的视角来看看吧。
let's go!!!!!!!!
Part1. 线程基础概念
线程向下增长,从高地址走向低地址。
mmap 的作用:开辟一块内存空间,完成物理内存到用户地址空间的映射;同时也可以实现从磁盘文件映射到内存,再映射到用户空间。
不是只有进程可以调用 mmap,线程同样可以利用该机制完成内存区域的申请与映射操作。
Part1.1. 线程与进程的区别
线程是独立执行流:
• 每一条线程都拥有属于自己独立的 PCB / TCB(线程控制块)
• 自带独立栈结构,拥有自己的执行上下文
• 在同一个进程内部,线程之间可以互相访问彼此的全部资源
• 资源完全共享:一个线程可以访问同一个进程里面其余所有线程拥有的资源
核心区别:
• 进程:资源独立,彼此隔离
• 线程:资源共享,执行流独立
Part1.2. 线程封装信息
每创建出来一条线程,内部都会封装保存该线程的全部关键属性:
• tid:线程 ID
• name:线程名字
• isdetach:是否为分离态
• isrunning:是否正在运行
• 线程状态(就绪 / 运行 / 阻塞)
• 其他线程自带信息(创建时 pthread_create 填入)
Part1.3. 线程私有存储
关键字:****__thread
示例代码:
__thread int a = 0;
原理:被 __thread 修饰的变量,存放在每一条线程的局部存储之中。
不是全局共享变量!
• 如果进程里面一共有 5 条线程,那么变量 a 在内存中一共存在 5 份
• 每一条线程各自持有独属于自己的一份
• 互相之间互不干扰,不会发生共享、不会互相覆盖
典型用途:存放线程专属名字,将线程 name 存入线程局部存储里面。
Part1.4. 线程名字操作接口
设置线程名称
cpppthread_setname_np(pthread_t tid, const char *name);• 参数 1:目标线程 id
• 参数 2:想要设置的线程名字
• 功能:给指定 tid 的线程设置名字
获取线程名称
cpppthread_getname_np(pthread_t tid, char *name, size_t len);• 参数 1:目标线程 id
• 参数 2:缓冲区,用来接收读取出来的线程名字
• 参数 3:缓冲区长度
• 功能:读取目标线程保存的线程名,将名字写入传入的缓冲区内部
Part2. 线程资源共享带来的问题
同一个进程内部全部线程,都可以直接操作进程里面的公共资源。
因为资源完全互通,就会衍生大量并发安全问题。
举一个经典例子:
多条线程同时操作同一个全局计数器,多条线程争抢修改计数变量。• 计数变量自增不是原子操作
• 自增拆分为:读取数值 → 计算加一 → 写回内存
• 如果中途发生线程切换,就会造成数据覆盖
• 最终结果:少计数、数值错乱,得不到预期结果
根源:没有保护的共享资源,并发随机访问,操作穿插,产生未定义结果。
Part2.1. 线程切换触发时机
很多人误以为只有 sleep 才会造成线程切换,实际并不是
• 不是只有 sleep 才会发生线程切换
• sleep、阻塞 IO(键盘输入)会主动进入内核,触发切换
• 就算没有 sleep,调用库函数(例如 printf)也会进入内核
• 只要调用进入内核的函数,就存在线程切换的可能性
• 用户态里面执行大量循环计算,时间片耗尽,同样强制切换
切换代价:调用越多,来回切换越频繁,系统开销越大。
最优写法:尽量减少无意义频繁调用,降低切换频率。
Part2.2. 锁的引入
为了解决多线程资源竞争,操作系统提供互斥锁(mutex),用来保护临界资源,保证操作原子性。
Part3. 互斥锁
Part3.1. 初始化函数
cppint pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);• 参数一:互斥锁变量地址
• 参数二:锁属性,传 NULL 使用默认属性
• 返回值:成功返回 0;失败返回错误编号
两种初始化方式:
方式一:静态初始化(常量初始化)
cpppthread_mutex_t a = PTHREAD_MUTEX_INITIALIZER;• 直接赋值宏初始化锁
• 不需要手动调用销毁
• 自动释放,简单快捷
• 适合全局锁变量
方式二:动态初始化
自定义变量创建锁:
1. 定义锁变量
2. 使用 pthread_mutex_init 初始化
3. 使用完成之后,必须调用销毁函数释放资源
销毁接口:
cppint pthread_mutex_destroy(pthread_mutex_t *mutex);销毁已经不再使用的互斥锁,释放锁占用的内核资源。
如果不销毁,会造成资源泄漏。
Part3.2. 核心接口
上锁
cppint pthread_mutex_lock(pthread_mutex_t *a);• 如果锁目前没有被占有:上锁成功,拿到锁,继续向下执行
• 如果锁已经被别的线程拿走:当前线程阻塞休眠,加入锁等待队列,挂起等待
• 获取锁成功之后,才会从函数返回继续运行
解锁
cppint pthread_mutex_unlock(pthread_mutex_t *a);• 释放当前线程持有的锁
• 解锁之后,内核唤醒等待队列里面等待这一把锁的线程
• 锁交给等待的其中一条线程持有
Part3.3. 锁与临界资源
锁本身也是临界资源!
申请锁、争夺锁的操作,本身就存在竞争。所以锁内部的争夺逻辑本身必须保证原子操作。
申请锁失败的线程,不会一直空循环抢占 CPU;操作系统会将该线程阻塞挂起,进入等待队列,让出 CPU。
拿到锁的线程进入临界区执行代码;就算执行中途发生线程切换,别的线程进来,发现锁已经被占有,直接阻塞,无法进入临界代码段。
拿到锁之后内部允许线程切换,但是别的线程拿不到锁,无法进入保护区域执行代码,从而实现保护。
Part3.4. 锁与值传递
cpppthread_mutex_t a; pthread_mutex_t *p = &a;不能直接传值传递 mutex!
• pthread_mutex_t 如果直接拷贝赋值,传递的只是锁的值副本
• 复制出来的锁不是同一把锁
• 明明看着变量一模一样,实际是两把完全独立的锁
• 最后变成一人一把锁,保护直接失效,完全锁不住资源
正确用法:
传递锁的地址(指针),保证所有线程操作的是同一把锁!
口诀:锁必须传地址,不能传值拷贝!
Part3.5. 互斥锁底层原理
锁的实现分为两大方案:硬件实现 + 软件实现。
方案①:硬件实现
依靠硬件指令完成锁操作:关闭外部中断。
关闭中断之后:
• 屏蔽外部所有中断信号
• 没有中断就不会触发线程调度切换
• 当前执行流独占运行,不会被打断
• 保证上锁、判断操作一次性执行完成
执行完毕之后,重新打开中断,恢复调度。
优点:速度极快;缺点:关闭中断影响整个系统调度,大型项目很少单独使用。
方案②:软件实现
多步骤判断完成锁抢占:
1. 判断锁当前有没有持有者
2. 如果无人持有:将锁内部标记置为持有
3. 如果已经有人持有:进入等待队列阻塞挂起
4. 当前持有者解锁之后,唤醒等待队列里面等待线程
内核维护锁内部标记值,记录锁持有者状态,实现排队抢占。
Part3.6. 锁运行过程
假设现在存在两条线程:线程 A、线程 B
流程演示:
1. 线程 A 抢先拿到 mutex 锁,上锁成功
2. A 进入临界区执行代码
3. 运行中途发生线程切换,切到线程 B
4. B 执行上锁操作,发现锁已经被 A 占有
5. B 获取锁失败,直接阻塞挂起,进入锁等待队列
6. CPU 切回线程 A,A 执行完毕,调用 unlock 解锁
7. 解锁的时候内核将 mutex 标记设置为空闲
8. 内核唤醒等待队列里面等待锁的线程 B
9. B 获取锁成功,进入临界区继续执行代码
不是解锁直接指定交给哪一个线程,是内核调度自动分配,保证所有申请上锁的线程公平竞争,具备一定顺序性。
Part3.7. 线程的同步
单纯互斥只是排队访问资源;同步是让多条线程按照预定顺序执行。
同步规则:
• 如果有一条线程抢占拿到资源,其余线程不能继续执行
• 使用条件变量 + 互斥锁配合,让全部线程有序排队
• 不是随便争抢,按照业务需求的顺序依次执行
• 保证多线程执行流程可控,不会乱序
同步 = 在互斥基础之上,加上执行先后顺序约束。
Part4. 结语
这篇文章我们深入的知道了线程的相关知识,接下来,小编还会带来更多Linux相关的知识,敬请期待~
最后,祝大家可以:春风得意马蹄疾,一日看尽长安花!最后的最后,要是觉得本文还可以的话,可以点点赞,关注小编一波,谢谢大家!~
