文章详情

登录

短信预约-IT技能 免费直播动态提醒

选择考试省份

  • 北京
  • 上海
  • 天津
  • 重庆
  • 河北
  • 山东
  • 辽宁
  • 黑龙江
  • 吉林
  • 甘肃
  • 青海
  • 河南
  • 江苏
  • 湖北
  • 湖南
  • 江西
  • 浙江
  • 广东
  • 云南
  • 福建
  • 海南
  • 山西
  • 四川
  • 陕西
  • 贵州
  • 安徽
  • 广西
  • 内蒙
  • 西藏
  • 新疆
  • 宁夏
  • 兵团

请输入下面的图形验证码

提交验证

短信预约提醒成功

【Linux】线程安全（万字详解）

2023-08-19 12:52

关注

🎇Linux：

  • 博客主页：一起去看日落吗
  • 分享博主的在Linux中学习到的知识和遇到的问题
  • 博主的能力有限，出现错误希望大家不吝赐教
  • 分享给大家一句我很喜欢的话： 看似不起波澜的日复一日，一定会在某一天让你看见坚持的意义，祝我们都能在鸡零狗碎里找到闪闪的快乐🌿🌞🐾。

在这里插入图片描述

🍁 🍃 🍂 🌿

目录

🍁1. Linux线程互斥

🍂1.1 进程线程间的互斥相关背景概念

进程之间如果要进行通信我们需要先创建第三方资源，让不同的进程看到同一份资源，由于这份第三方资源可以由操作系统中的不同模块提供，于是进程间通信的方式有很多种。进程间通信中的第三方资源就叫做临界资源，访问第三方资源的代码就叫做临界区。

而多线程的大部分资源都是共享的，线程之间进行通信不需要费那么大的劲去创建第三方资源。

例如，我们只需要在全局区定义一个count变量，让新线程每隔一秒对该变量加一操作，让主线程每隔一秒获取count变量的值进行打印。

#include #include #include int count = 0;void* Routine(void* arg){while (1){count++;sleep(1);}pthread_exit((void*)0);}int main(){pthread_t tid;pthread_create(&tid, NULL, Routine, NULL);while (1){printf("count: %d\n", count);sleep(1);}pthread_join(tid, NULL);return 0;}

在这里插入图片描述
此时我们相当于实现了主线程和新线程之间的通信，其中全局变量count就叫做临界资源，因为它被多个执行流共享，而主线程中的printf和新线程中count++就叫做临界区，因为这些代码对临界资源进行了访问。

在多线程情况下，如果这多个执行流都自顾自的对临界资源进行操作，那么此时就可能导致数据不一致的问题。解决该问题的方案就叫做互斥，互斥的作用就是，保证在任何时候有且只有一个执行流进入临界区对临界资源进行访问。

原子性指的是不可被分割的操作，该操作不会被任何调度机制打断，该操作只有两态，要么完成，要么未完成。

例如，下面我们模拟实现一个抢票系统，我们将记录票的剩余张数的变量定义为全局变量，主线程创建四个新线程，让这四个新线程进行抢票，当票被抢完后这四个线程自动退出。

在这里插入图片描述
其中出现了剩余票数为负数的情况。

该代码中记录剩余票数的变量tickets就是临界资源，因为它被多个执行流同时访问，而判断tickets是否大于0、打印剩余票数以及–tickets这些代码就是临界区，因为这些代码对临界资源进行了访问。

剩余票数出现负数的原因：

我们对一个变量进行–，我们实际需要进行以下三个步骤：

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

在这里插入图片描述
既然–操作需要三个步骤才能完成，那么就有可能当thread1刚把tickets的值读进CPU就被切走了，也就是从CPU上剥离下来，假设此时thread1读取到的值就是1000，而当thread1被切走时，寄存器中的1000叫做thread1的上下文信息，因此需要被保存起来，之后thread1就被挂起了。

假设此时thread2被调度了，由于thread1只进行了–操作的第一步，因此thread2此时看到tickets的值还是1000，而系统给thread2的时间片可能较多，导致thread2一次性执行了100次–才被切走，最终tickets由1000减到了900。

此时系统再把thread1恢复上来，恢复的本质就是继续执行thread1的代码，并且要将thread1曾经的硬件上下文信息恢复出来，此时寄存器当中的值是恢复出来的1000，然后thread1继续执行–操作的第二步和第三步，最终将999写回内存。

在上述过程中，thread1抢了1张票，thread2抢了100张票，而此时剩余的票数却是999，也就相当于多出了100张票。

因此对一个变量进行–操作并不是原子的，虽然–tickets看起来就是一行代码，但这行代码被编译器编译后本质上是三行汇编，相反，对一个变量进行++也需要对应的三个步骤，即++操作也不是原子操作。

🍂1.2 互斥量mutex

要解决上述抢票系统的问题，需要做到三点：

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

在这里插入图片描述

🍂1.3 互斥量的接口

初始化互斥量的函数叫做pthread_mutex_init

int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);

参数说明：

返回值说明：

调用pthread_mutex_init函数初始化互斥量叫做动态分配，除此之外，我们还可以用下面这种方式初始化互斥量，该方式叫做静态分配：

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

销毁互斥量的函数叫做pthread_mutex_destroy

int pthread_mutex_destroy(pthread_mutex_t *mutex);

参数说明：

返回值说明：

销毁互斥量需要注意：

互斥量加锁的函数叫做pthread_mutex_lock

int pthread_mutex_lock(pthread_mutex_t *mutex);

参数说明：

返回值说明：

调用pthread_mutex_lock时，可能会遇到以下情况:

互斥量解锁的函数叫做pthread_mutex_unlock

int pthread_mutex_unlock(pthread_mutex_t *mutex);

参数说明：

返回值说明：

例如，我们在上述的抢票系统中引入互斥量，每一个线程要进入临界区之前都必须先申请锁，只有申请到锁的线程才可以进入临界区对临界资源进行访问，并且当线程出临界区的时候需要释放锁，这样才能让其余要进入临界区的线程继续竞争锁。

#include #include #include int tickets = 1000;pthread_mutex_t mutex;void* TicketGrabbing(void* arg){const char* name = (char*)arg;while (1){pthread_mutex_lock(&mutex);if (tickets > 0){usleep(100);printf("[%s] get a ticket, left: %d\n", name, --tickets);pthread_mutex_unlock(&mutex);}else{pthread_mutex_unlock(&mutex);break;}}printf("%s quit!\n", name);pthread_exit((void*)0);}int main(){pthread_mutex_init(&mutex, NULL);pthread_t t1, t2, t3, t4;pthread_create(&t1, NULL, TicketGrabbing, "thread 1");pthread_create(&t2, NULL, TicketGrabbing, "thread 2");pthread_create(&t3, NULL, TicketGrabbing, "thread 3");pthread_create(&t4, NULL, TicketGrabbing, "thread 4");pthread_join(t1, NULL);pthread_join(t2, NULL);pthread_join(t3, NULL);pthread_join(t4, NULL);pthread_mutex_destroy(&mutex);return 0;}

此时在抢票过程中就不会出现票数剩余为负数的情况了。
在这里插入图片描述

注意：

🍂1.4 互斥量实现原理探究

引入互斥量后，当一个线程申请到锁进入临界区时，在其他线程看来该线程只有两种状态，要么没有申请锁，要么锁已经释放了，因为只有这两种状态对其他线程才是有意义的。

图中线程1进入临界区后，在线程2、3、4看来，线程1要么没有申请锁，要么线程1已经将锁释放了，因为只有这两种状态对线程2、3、4才是有意义的，当线程2、3、4检测到其他状态时也就被阻塞了。

在这里插入图片描述
此时对于线程2、3、4而言，它们就认为线程1的整个操作过程是原子的。

临界区内的线程完全可能进行线程切换，但即便该线程被切走，其他线程也无法进入临界区进行资源访问，因为此时该线程是拿着锁被切走的，锁没有被释放也就意味着其他线程无法申请到锁，也就无法进入临界区进行资源访问了。

其他想进入该临界区进行资源访问的线程，必须等该线程执行完临界区的代码并释放锁之后，才能申请锁，申请到锁之后才能进入临界区。

我们说被多个执行流共享的资源叫做临界资源，访问临界资源的代码叫做临界区。所有的线程在进入临界区之前都必须竞争式的申请锁，因此锁也是被多个执行流共享的资源，也就是说锁本身就是临界资源。

既然锁是临界资源，那么锁就必须被保护起来，但锁本身就是用来保护临界资源的，那锁又由谁来保护的呢？

锁实际上是自己保护自己的，我们只需要保证申请锁的过程是原子的，那么锁就是安全的。

操作系统的工作原理：

下面我们来看看lock和unlock的伪代码：

在这里插入图片描述

我们可以认为mutex的初始值为1，al是计算机中的一个寄存器，当线程申请锁时，需要执行以下步骤：

  1. 先将al寄存器中的值清0。该动作可以被多个线程同时执行，因为每个线程都有自己的一组寄存器（上下文信息），执行该动作本质上是将自己的al寄存器清0。
  2. 然后交换al寄存器和mutex中的值。xchgb是体系结构提供的交换指令，该指令可以完成寄存器和内存单元之间数据的交换。
  3. 最后判断al寄存器中的值是否大于0。若大于0则申请锁成功，此时就可以进入临界区访问对应的临界资源；否则申请锁失败需要被挂起等待，直到锁被释放后再次竞争申请锁。

当线程释放锁时，需要执行以下步骤：

  1. 将内存中的mutex置回1。使得下一个申请锁的线程在执行交换指令后能够得到1
  2. 唤醒等待Mutex的线程。唤醒这些因为申请锁失败而被挂起的线程，让它们继续竞争申请锁

注意：

🍁2. 可重入VS线程安全

🍂2.1 概念

注意： 线程安全讨论的是线程执行代码时是否安全，重入讨论的是函数被重入进入。

🍂2.2 常见的线程不安全的情况

🍂2.3 常见的线程安全的情况

🍂2.4 常见的不可重入的情况

🍂2.5 常见的可重入的情况

🍂2.6 可重入与线程安全联系

🍂2.7 可重入与线程安全区别

🍁3. 常见锁概念

🍂3.1 死锁

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

单执行流也有可能产生死锁，如果某一执行流连续申请了两次锁，那么此时该执行流就会被挂起。因为该执行流第一次申请锁的时候是申请成功的，但第二次申请锁时因为该锁已经被申请过了，于是申请失败导致被挂起直到该锁被释放时才会被唤醒，但是这个锁本来就在自己手上，自己现在处于被挂起的状态根本没有机会释放锁，所以该执行流将永远不会被唤醒，此时该执行流也就处于一种死锁的状态。

例如，在下面的代码中我们让主线程创建的新线程连续申请了两次锁。

#include #include pthread_mutex_t mutex;void* Routine(void* arg){pthread_mutex_lock(&mutex);pthread_mutex_lock(&mutex);pthread_exit((void*)0);}int main(){pthread_t tid;pthread_mutex_init(&mutex, NULL);pthread_create(&tid, NULL, Routine, NULL);pthread_join(tid, NULL);pthread_mutex_destroy(&mutex);return 0;}

用ps命令查看该进程时可以看到，该进程当前的状态是Sl+，其中的l实际上就是lock的意思，表示该进程当前处于一种死锁的状态。
在这里插入图片描述

进程运行时是被CPU调度的，换句话说进程在调度时是需要用到CPU资源的，每个CPU都有一个运行等待队列（runqueue），CPU在运行时就是从该队列中获取进程进行调度的。

在这里插入图片描述

在运行等待队列中的进程本质上就是在等待CPU资源，实际上不止是等待CPU资源如此，等待其他资源也是如此，比如锁的资源、磁盘的资源、网卡的资源等等，它们都有各自对应的资源等待队列。

在这里插入图片描述

例如，当某一个进程在被CPU调度时，该进程需要用到锁的资源，但是此时锁的资源正在被其他进程使用：

总结：

🍂3.2 死锁的四个必要条件

注意： 这是死锁的四个必要条件，也就是说只有同时满足了这四个条件才可能产生死锁。

🍂3.3 避免死锁

🍁4. Linux线程同步

🍂4.1 同步概念与竞态条件

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

竞态条件： 因为时序问题，而导致程序异常，我们称之为竞态条件。

例如，现在有两个线程访问一块临界区，一个线程往临界区写入数据，另一个线程从临界区读取数据，但负责数据写入的线程的竞争力特别强，该线程每次都能竞争到锁，那么此时该线程就一直在执行写入操作，直到临界区被写满，此后该线程就一直在进行申请锁和释放锁。而负责数据读取的线程由于竞争力太弱，每次都申请不到锁，因此无法进行数据的读取，引入同步后该问题就能很好的解决。

🍂4.2 条件变量

条件变量是利用线程间共享的全局变量进行同步的一种机制，条件变量是用来描述某种资源是否就绪的一种数据化描述。

条件变量主要包括两个动作：

条件变量通常需要配合互斥锁一起使用。

🍂4.3 条件变量函数

初始化条件变量的函数叫做pthread_cond_init

int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);

参数说明：

返回值说明：

调用pthread_cond_init函数初始化条件变量叫做动态分配，除此之外，我们还可以用下面这种方式初始化条件变量，该方式叫做静态分配：

pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

销毁条件变量的函数叫做pthread_cond_destroy

int pthread_cond_destroy(pthread_cond_t *cond);

参数说明：

返回值说明：

销毁条件变量需要注意：

等待条件变量满足的函数叫做pthread_cond_wait

int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);

参数说明：

返回值说明：

唤醒等待的函数有以下两个：

int pthread_cond_broadcast(pthread_cond_t *cond);int pthread_cond_signal(pthread_cond_t *cond);

区别：

参数说明：

返回值说明：

例如，下面我们用主线程创建三个新线程，让主线程控制这三个新线程活动。这三个新线程创建后都在条件变量下进行等待，直到主线程检测到键盘有输入时才唤醒一个等待线程，如此进行下去。

#include #include #include pthread_mutex_t mutex;pthread_cond_t cond;void* Routine(void* arg){pthread_detach(pthread_self());std::cout << (char*)arg << " run..." << std::endl;while (true){pthread_cond_wait(&cond, &mutex); //阻塞在这里，直到被唤醒std::cout << (char*)arg << "活动..." << std::endl;}}int main(){pthread_t t1, t2, t3;pthread_mutex_init(&mutex, nullptr);pthread_cond_init(&cond, nullptr);pthread_create(&t1, nullptr, Routine, (void*)"thread 1");pthread_create(&t2, nullptr, Routine, (void*)"thread 2");pthread_create(&t3, nullptr, Routine, (void*)"thread 3");while (true){getchar();pthread_cond_signal(&cond);}pthread_mutex_destroy(&mutex);pthread_cond_destroy(&cond);return 0;}

此时我们会发现唤醒这三个线程时具有明显的顺序性，根本原因是当这若干个线程启动时默认都会在该条件变量下去等待，而我们每次都唤醒的是在当前条件变量下等待的头部线程，当该线程执行完打印操作后会继续排到等待队列的尾部进行wait，所以我们能够看到一个周转的现象。

在这里插入图片描述
如果我们想每次唤醒都将在该条件变量下等待的所有线程进行唤醒，可以将代码中的pthread_cond_signal函数改为pthread_cond_broadcast函数。

此时我们每一次唤醒都会将所有在该条件变量下等待的线程进行唤醒，也就是每次都将这三个线程唤醒。

🍂4.3 为什么pthread_cond_wait需要互斥量

在这里插入图片描述

总结:

你可能会想：当我们进入临界区上锁后，如果发现条件不满足，那我们先解锁，然后在该条件变量下进行等待不就行了。

//错误的设计pthread_mutex_lock(&mutex);while (condition_is_false){pthread_mutex_unlock(&mutex);//解锁之后，等待之前，条件可能已经满足，信号已经发出，但是该信号可能被错过pthread_cond_wait(&cond);pthread_mutex_lock(&mutex);}pthread_mutex_unlock(&mutex);

但这是不可行的，因为解锁和等待不是原子操作，调用解锁之后，在调用pthread_cond_wait函数之前，如果已经有其他线程获取到互斥量，发现此时条件满足，于是发送了信号，那么此时pthread_cond_wait函数将错过这个信号，最终可能会导致线程永远不会被唤醒，因此解锁和等待必须是一个原子操作。

而实际进入pthread_cond_wait函数后，会先判断条件变量是否等于0，若等于0则说明不满足，此时会先将对应的互斥锁解锁，直到pthread_cond_wait函数返回时再将条件变量改为1，并将对应的互斥锁加锁。

🍂4.4 条件变量使用规范

等待条件变量的代码

pthread_mutex_lock(&mutex);while (条件为假)pthread_cond_wait(&cond, &mutex);修改条件pthread_mutex_unlock(&mutex);

唤醒等待线程的代码

pthread_mutex_lock(&mutex);设置条件为真pthread_cond_signal(&cond);pthread_mutex_unlock(&mutex);

来源地址：https://blog.csdn.net/m0_60338933/article/details/128891099

阅读原文内容投诉

免责声明：

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的，并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据，供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

软考中级精品资料免费领

  • 历年真题答案解析
  • 备考技巧名师总结
  • 高频考点精准押题

  • 2024年上半年信息系统项目管理师第二批次真题及答案解析（完整版）

    难度     813人已做
    查看

  • 【考后总结】2024年5月26日信息系统项目管理师第2批次考情分析

    难度     354人已做
    查看

  • 【考后总结】2024年5月25日信息系统项目管理师第1批次考情分析

    难度     318人已做
    查看

  • 2024年上半年软考高项第一、二批次真题考点汇总（完整版）

    难度     435人已做
    查看

  • 2024年上半年系统架构设计师考试综合知识真题

    难度     224人已做
    查看

相关文章

发现更多好内容

猜你喜欢

AI推送时光机

【Linux】线程安全（万字详解）

人工智能2023-08-19

【Linux】进程信号万字详解（上）

人工智能2023-08-31

C# 线程安全详解

人工智能2024-04-02

Java多线程之线程安全问题详解

人工智能2024-04-02

java多线程创建及线程安全详解

人工智能2024-04-02

Java线程安全与非线程安全解析

人工智能2023-05-31

Java 中的泛型（两万字超全详解）

人工智能2023-08-16

【Java系列】详解多线程（三）—— 线程安全（下篇）

【Java系列】详解多线程（三）—— 线程安全（下篇）
人工智能2023-12-22

SimpleDateFormat线程安全问题排查详解

人工智能2022-11-13

Java使用线程同步解决线程安全问题详解

人工智能2024-04-02

Java多线程 - 线程安全和线程同步解决线程安全问题

人工智能2023-08-20

详解CopyOnWriteArrayList是如何保证线程安全

人工智能2024-04-02

关于java中线程安全问题详解

人工智能2024-04-02

Linux strcat函数：字符串处理的多线程安全

Linux strcat函数：字符串处理的多线程安全
人工智能2024-09-14

Java多线程之线程安全问题详情

人工智能2024-04-02

一文详解Java线程中的安全策略

人工智能2024-04-02

Spring在SingleTon模式下的线程安全详解

人工智能2024-04-02

Java中线程状态+线程安全问题+synchronized的用法详解

人工智能2024-04-02

Python全栈之线程详解

人工智能2024-04-02

详解SimpleDateFormat的线程安全问题与解决方案

人工智能2023-05-31
位置：首页-资讯-人工智能
咦！没有更多了？去看看其它编程学习网 内容吧
首页课程
资料下载问答资讯