【知识讲解】 Linux线程中锁的认识


目录

前言

[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. 线程名字操作接口

设置线程名称

cpp 复制代码
pthread_setname_np(pthread_t tid, const char *name);

• 参数 1:目标线程 id

• 参数 2:想要设置的线程名字

• 功能:给指定 tid 的线程设置名字

获取线程名称

cpp 复制代码
pthread_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. 初始化函数

cpp 复制代码
int pthread_mutex_init(pthread_mutex_t *restrict mutex,
                      const pthread_mutexattr_t *restrict attr);

• 参数一:互斥锁变量地址

• 参数二:锁属性,传 NULL 使用默认属性

• 返回值:成功返回 0;失败返回错误编号

两种初始化方式:

方式一:静态初始化(常量初始化)

cpp 复制代码
pthread_mutex_t a = PTHREAD_MUTEX_INITIALIZER;

• 直接赋值宏初始化锁

• 不需要手动调用销毁

• 自动释放,简单快捷

• 适合全局锁变量

方式二:动态初始化

自定义变量创建锁:

1. 定义锁变量

2. 使用 pthread_mutex_init 初始化

3. 使用完成之后,必须调用销毁函数释放资源

销毁接口:

cpp 复制代码
int pthread_mutex_destroy(pthread_mutex_t *mutex);

销毁已经不再使用的互斥锁,释放锁占用的内核资源。
如果不销毁,会造成资源泄漏。


Part3.2. 核心接口

上锁

cpp 复制代码
int pthread_mutex_lock(pthread_mutex_t *a);

• 如果锁目前没有被占有:上锁成功,拿到锁,继续向下执行

• 如果锁已经被别的线程拿走:当前线程阻塞休眠,加入锁等待队列,挂起等待

• 获取锁成功之后,才会从函数返回继续运行

解锁

cpp 复制代码
int pthread_mutex_unlock(pthread_mutex_t *a);

• 释放当前线程持有的锁

• 解锁之后,内核唤醒等待队列里面等待这一把锁的线程

• 锁交给等待的其中一条线程持有


Part3.3. 锁与临界资源

锁本身也是临界资源!

申请锁、争夺锁的操作,本身就存在竞争。所以锁内部的争夺逻辑本身必须保证原子操作。

申请锁失败的线程,不会一直空循环抢占 CPU;操作系统会将该线程阻塞挂起,进入等待队列,让出 CPU。

拿到锁的线程进入临界区执行代码;就算执行中途发生线程切换,别的线程进来,发现锁已经被占有,直接阻塞,无法进入临界代码段。

拿到锁之后内部允许线程切换,但是别的线程拿不到锁,无法进入保护区域执行代码,从而实现保护。


Part3.4. 锁与值传递

cpp 复制代码
pthread_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相关的知识,敬请期待~
最后,祝大家可以:春风得意马蹄疾,一日看尽长安花!

最后的最后,要是觉得本文还可以的话,可以点点赞,关注小编一波,谢谢大家!~

相关推荐
无足鸟ICT19 分钟前
【RHCA+】系统调优配置文件
linux·服务器
时间的拾荒人2 小时前
Shell 脚本核心语法详解(下篇):流程控制、函数、重定向与文件包含
linux·运维·服务器·bash·脚本编程
蜗牛一步步往上爬3 小时前
第四章 更多的bash shell命令
linux·开发语言·bash
进击的荆棘4 小时前
Linux网络——网络基础概念
linux·运维·服务器·网络
.YM.Z4 小时前
从操作系统进入Linux进程概念及进程状态
linux·运维·服务器
忆挽篱笙歌10 小时前
通信连接,匿名管道
linux·服务器·网络
无足鸟ICT13 小时前
【RHCA+】安装Tuned
linux·服务器·centos
测试界的小码农17 小时前
【Linux 命令实战(06):Linux 文件权限管理,掌握 chmod、chown、chgrp】
linux·运维·服务器
一条破秋裤19 小时前
【1114】【并发控制】【笔记】
linux