【Linux】线程安全篇Ⅱ

最新推荐文章于 2024-07-27 19:02:51 发布
最新推荐文章于 2024-07-27 19:02:51 发布
阅读量311 收藏 1
点赞数 10
分类专栏： Linux 文章标签： linux 多线程 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Suk_god/article/details/124458849
版权

文章目录

0、接上篇

线程安全

1、同步存在的必要性

1.1 样例引入

有了互斥之后，为什么还要有同步呢？
这个问题值得我们讨论，我们知道，互斥通过控制线程的访问时序从而保证线程的安全。既然线程已经是安全的了，那还有同步什么事情呢？
我们通过一个例子慢慢体会一下：

现在有一个这样的场景：
有两个人，A和B，有一只碗，A一直向碗中做面，B一直从碗里吃面。

这种情况，我们看到的结果应该要是A做一碗，B吃一碗

将上述情景翻译为线程相关的描述就是：
有一个全局的临界资源g_bowl,其中g_bowl = 1表示有面， g_bowl = 0表示没面。有两个线程A和B，A是一个做面线程，只负责向碗里做面，B是一个吃面线程，只负责从碗里吃面。

我们想得到的结果：碗里没面，A去做，碗里有面，B去吃！

好的，我们通过代码模拟一下上面的场景：

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

#define THREAD_COUNT 1

int g_bowl = 0;//0-->没有面  1-->有面
pthread_mutex_t g_lock;


void* eat_thread_start(void* arg)
{
    while(1)
    {
        //加锁
        pthread_mutex_lock(&g_lock);
        printf("I am eat thread: eat %d\n",g_bowl--);
        //解锁
        pthread_mutex_unlock(&g_lock);
        usleep(1);
    }
}

void* make_thread_start(void* arg)
{
    while(1)
    {
        //加锁
        pthread_mutex_lock(&g_lock);
        printf("I am make thread: make %d\n",++g_bowl);
        //解锁
        pthread_mutex_unlock(&g_lock);
        usleep(1);
    }

}


int main()
{
    //初始化互斥锁
    pthread_mutex_init(&g_lock,NULL);

    pthread_t eat[THREAD_COUNT],make[THREAD_COUNT];
    //创建做面和吃面的线程
    for(int i = 0; i < THREAD_COUNT; i++)
    {
        int ret = pthread_create(&eat[i], NULL, eat_thread_start, NULL);
        if(ret < 0)
        {
            perror("pthread_create");
            return 0;
        }

        ret = pthread_create(&make[i], NULL, make_thread_start, NULL);
        if(ret < 0)
        {
            perror("pthread_create");
            return 0;
        }
    }

    //主线程等待工作线程
    for(int i = 0; i < THREAD_COUNT; i++)
    {
        pthread_join(eat[i],NULL);
        pthread_join(make[i],NULL);
    }

    //销毁互斥锁
    pthread_mutex_destroy(&g_lock);

    return 0;
}

输出结果：
在这里插入图片描述
从上面的例子我们可以得到这样一个信息：

1、仅仅有互斥是不能够满足我们的程序需求的
2、线程访问临界区代码存在不合理性

1.2 结论

1、多个线程保证了互斥，也就保证了线程能够独占访问临界资源了。但是，并不能保证线程访问临界资源的合理性
2、同步存在的意义就是保证多个线程对临界资源访问的合理性，这个合理性建立在互斥的基础上

那如何实现同步呢？我们可以通过判断的方式解决：
🆗，我们现在将上面的代码更改一下，通过判断的方式，保证线程访问临界资源的合理性~具体的思路如下图：
图解：
在这里插入图片描述
我们实现一下代码，其实很简单，只需要在两个线程的入口函数内部加上判断即可：
在这里插入图片描述
好的，我们来看一下运行结果：
在这里插入图片描述
我们发现结果貌似和我们想要的是一致了。但是这样的代码有什么问题没有？
我们结合代码来分析一下：
在这里插入图片描述
运行结果如下：
在这里插入图片描述
要想解决这个问题，我们就需要了解条件变量，使用条件变量接口来解决，而不是简单的判断解锁~

2、条件变量

2.1 条件变量的原理 && 使用

原理：
 条件变量本质上是一个PCB等待队列，存放着等待的线程的PCB
使用：
 线程在加锁之后，先判断临界资源是否可用，如果可用，直接访问临界资源，如果不可用，调用条件变量的等待接口，让线程进行等待。

2.3 条件变量的接口

初始化接口

  1. 动态初始化

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

cond：条件变量的指针（地址）
attr：表示条件变量的属性信息，一般传递NULL，表示使用默认属性

返回值

初始化成功 ---- 返回0
初始化失败-----设置errno并返回

  1. 静态初始化

pthread_cond_t cond = PTHREAD_COND_INITIALIZER；

等待接口

哪个线程调用等待接口，就将哪个线程放到条件变量对应的PCB等待队列中去

int pthread_cond_wait(pthread_cond_t* restrict cond,pthread_mutex_t *restrict mutex)
参数

cond：条件变量的指针（地址）
mutex：互斥锁

唤醒接口

int pthread_cond_broadcast(pthread_cond_t * cond)；
唤醒PCB等待队列当中的所有线程
int pthread_cond_signal(pthread_cond_t * cond)；
唤醒PCB等待队列当中的至少一个线程

销毁接口

将条件变量进行销毁
int pthread_cond_destroy(pthread_cond_t* cond)；
在这里插入图片描述

有了这些知识，我们再次对上面的代码做出如下修改：

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

#define THREAD_COUNT 1

int g_bowl = 0;//0-->没有面  1-->有面
pthread_mutex_t g_lock;
pthread_cond_t g_cond;

void* eat_thread_start(void* arg)
{
    while(1)
    {
        //加锁
        pthread_mutex_lock(&g_lock);
        if(g_bowl == 0)
        {
            printf("我是吃面人，碗里没有面，我就不吃了~~~\n");
            pthread_cond_wait(&g_cond,&g_lock);
        }
        printf("I am eat thread: eat %d\n",g_bowl--);
        //解锁
        pthread_mutex_unlock(&g_lock);

        //通知做面线程做面
        pthread_cond_signal(&g_cond);
    }
}

void* make_thread_start(void* arg)
{
    while(1)
    {
        //加锁
        pthread_mutex_lock(&g_lock);
        if(g_bowl == 1)
        {
            printf("我是做面人，碗里有面，我就不做了~~~\n");
            pthread_cond_wait(&g_cond,&g_lock);
        }

        printf("I am make thread: make %d\n",++g_bowl);
        //解锁
        pthread_mutex_unlock(&g_lock);
        //通知吃面线程吃面
        pthread_cond_signal(&g_cond);
    }

}


int main()
{
    //初始化互斥锁
    pthread_mutex_init(&g_lock,NULL);
    //初始化条件变量
    pthread_cond_init(&g_cond,NULL);

    pthread_t eat[THREAD_COUNT],make[THREAD_COUNT];
    //创建做面和吃面的线程
    for(int i = 0; i < THREAD_COUNT; i++)
    {
        int ret = pthread_create(&eat[i], NULL, eat_thread_start, NULL);
        if(ret < 0)
        {
            perror("pthread_create");
            return 0;
        }

        ret = pthread_create(&make[i], NULL, make_thread_start, NULL);
        if(ret < 0)
        {
            perror("pthread_create");
            return 0;
        }
    }

    //主线程等待工作线程
    for(int i = 0; i < THREAD_COUNT; i++)
    {
        pthread_join(eat[i],NULL);
        pthread_join(make[i],NULL);
    }

    //销毁互斥锁
    pthread_mutex_destroy(&g_lock);
    //销毁条件变量
    pthread_cond_destroy(&g_cond);
    return 0;
}

分析代码：
在这里插入图片描述

运行结果：
在这里插入图片描述
但是，对于多个吃面线程和多个做面线程是否依旧成立呢？我们将县城徐良更改后看一下现象：
在这里插入图片描述
让程序跑起来，通过pstack查看线程数量，确保创建的线程符合我们的预期

一共有5个线程，一个主线程和4个工作线程。4个工作线程由2个做面线程和2个吃面线程组成。符合我们的预期
在这里插入图片描述
分析运行结果：
在这里插入图片描述
为什么会出现这样的现象，是值得我们深思的地方。要想理清楚这里面的缘由，我们需要先搞清楚pthread_cond_wait这个接口都做了些什么工作

2.4 条件变量夺命追问

条件变量的等待接口第二个参数为什么会有互斥锁

前提：在线程访问临界资源之前,一定是加锁访问的，因为要保证互斥！
将互斥锁传递给pthread_cond_wait接口，目的就是让该接口在内部执行解锁操作

为什么要解锁呢？通过下面的分析你可以得到答案
在这里插入图片描述

pthread_cond_wait的内部针对互斥锁做了什么操作？先释放互斥锁还是先将线程放到PCB等待队列？

1、pthread_cond_wait接口在内部对互斥锁进行了解锁操作
2、先将线程放到PCB等待队列，再释放互斥锁

执行先后的原因如下：
在这里插入图片描述
对于上图的两种情况，分别进行分析：
在这里插入图片描述
因此，情况二才是正确的。即先将线程放到PCB等待队列，再对互斥锁进行解锁

线程被唤醒之后会执行什么代码？

pthread_cond_wait函数在被唤醒之后一定会在其内部进行加锁操作

当然，加锁的权限和其他不在PCB等待队列中的线程是一样的，也就是说，它并不一定就能够抢到锁。

1、抢到锁了：pthread_cond_wait函数就真正执行完毕了,函数返回。
2、没有抢到锁：pthread_cond_wait函数没有真正的执行完毕，还处于内部抢锁的逻辑当中，还会继续去抢锁，直到抢到互斥锁后才返回

2.5 条件变量的代码

好的，我们在了解了pthread_cond_wait接口更多细节之后，我们来分析一下，为什么吃面线程和做面线程由1个变为2个之后，程序就出错了呢？

分析的前提场景如下图：
在这里插入图片描述
下面描述的场景是有可能存在的，由于线程间是抢占式执行的，因此在分析问题的时候常常使用假设的方式：
在这里插入图片描述
那么，我们应该如何更改这个代码呢？
只需要将线程入口函数处的条件判断if更改为while，在pthread_cond_wait接口退出的时候就会循环上去判断临界资源是否可用，进而保证了临界资源访问的合理性！
具体代码如下：

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

#define THREAD_COUNT 2

int g_bowl = 0;//0-->没有面  1-->有面
pthread_mutex_t g_lock;
pthread_cond_t g_cond;

void* eat_thread_start(void* arg)
{
    while(1)
    {
        //加锁
        pthread_mutex_lock(&g_lock);
        while(g_bowl == 0)
        {
            printf("我是吃面人%p，碗里没有面，我就不吃了~~~\n",pthread_self());
            pthread_cond_wait(&g_cond,&g_lock);
        }
        printf("我是吃面人%p: eat %d\n",pthread_self(),g_bowl--);
        //解锁
        pthread_mutex_unlock(&g_lock);

        //通知做面线程做面
        pthread_cond_signal(&g_cond);
    }
}

void* make_thread_start(void* arg)
{
    while(1)
    {
        //加锁
        pthread_mutex_lock(&g_lock);
        while(g_bowl == 1)
        {
            printf("我是做面人%p，碗里有面，我就不做了~~~\n",pthread_self());
            pthread_cond_wait(&g_cond,&g_lock);
        }

        printf("我是做面人%p: make %d\n",pthread_self(),++g_bowl);
        //解锁
        pthread_mutex_unlock(&g_lock);
        //通知吃面线程吃面
        pthread_cond_signal(&g_cond);
    }
}


int main()
{
    //初始化互斥锁
    pthread_mutex_init(&g_lock,NULL);
    //初始化条件变量
    pthread_cond_init(&g_cond,NULL);

    pthread_t eat[THREAD_COUNT],make[THREAD_COUNT];
    //创建做面和吃面的线程
    for(int i = 0; i < THREAD_COUNT; i++)
    {
        int ret = pthread_create(&eat[i], NULL, eat_thread_start, NULL);
        if(ret < 0)
        {
            perror("pthread_create");
            return 0;
        }

        ret = pthread_create(&make[i], NULL, make_thread_start, NULL);
        if(ret < 0)
        {
            perror("pthread_create");
            return 0;
        }
    }

    //主线程等待工作线程
    for(int i = 0; i < THREAD_COUNT; i++)
    {
        pthread_join(eat[i],NULL);
        pthread_join(make[i],NULL);
    }

    //销毁互斥锁
    pthread_mutex_destroy(&g_lock);
    //销毁条件变量
    pthread_cond_destroy(&g_cond);
    return 0;
}

运行结果
在这里插入图片描述
但是，我们又发现了一个问题，程序运行一段时间就卡死了，也不会退出！
遇到这种情况，我们先通过pstack来查看一下每个线程的状态，进而分析程序出错的原因
在这里插入图片描述
为什么会出现所有的工作线程都处于PCB等待队列中呢？
原因是，在线程通知PCB等待队列中的线程的时候，将同种类的线程通知出来了，然后判断临界资源是不可用状态，因此刚被通知出来的线程什么工作也没有做，就又进入PCB等待队列中了。

那因该如何解决这种问题呢？
 只需要将吃面线程和做面线程的条件变量分开就可以了。这样吃面线程通知的永远是做面线程条件变量对应的PCB等待队列，做面线程通知的永远是吃面线程条件变量对应的PCB等待队列。这样就不会出现上述的情况了！

🆗，理解到这里我们重新更改一下代码：
这里的代码已经是终极版本了，代码解决了多线程的安全性问题以及对临界资源的访问合理性问题！！

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

#define THREAD_COUNT 2

int g_bowl = 0;//0-->没有面  1-->有面
pthread_mutex_t g_lock;
pthread_cond_t g_eat_cond;//吃面线程的条件变量
pthread_cond_t g_make_cond;//做面线程的条件变量

void* eat_thread_start(void* arg)
{
    while(1)
    {
        //加锁
        pthread_mutex_lock(&g_lock);
        while(g_bowl == 0)
        {
            printf("我是吃面人%p，碗里没有面，我就不吃了~~~\n",pthread_self());
            pthread_cond_wait(&g_eat_cond,&g_lock);
        }
        printf("我是吃面人%p: eat %d\n",pthread_self(),g_bowl--);
        //解锁
        pthread_mutex_unlock(&g_lock);

        //通知做面线程做面
        pthread_cond_signal(&g_make_cond);
    }
}

void* make_thread_start(void* arg)
{
    while(1)
    {
        //加锁
        pthread_mutex_lock(&g_lock);
        while(g_bowl == 1)
        {
            printf("我是做面人%p，碗里有面，我就不做了~~~\n",pthread_self());
            pthread_cond_wait(&g_make_cond,&g_lock);
        }

        printf("我是做面人%p: make %d\n",pthread_self(),++g_bowl);
        //解锁
        pthread_mutex_unlock(&g_lock);
        //通知吃面线程吃面
        pthread_cond_signal(&g_eat_cond);
    }
}


int main()
{
    //初始化互斥锁
    pthread_mutex_init(&g_lock,NULL);
    //初始化条件变量
    pthread_cond_init(&g_eat_cond,NULL);
    pthread_cond_init(&g_make_cond,NULL);
    pthread_t eat[THREAD_COUNT],make[THREAD_COUNT];
    //创建做面和吃面的线程
    for(int i = 0; i < THREAD_COUNT; i++)
    {
        int ret = pthread_create(&eat[i], NULL, eat_thread_start, NULL);
        if(ret < 0)
        {
            perror("pthread_create");
            return 0;
        }

        ret = pthread_create(&make[i], NULL, make_thread_start, NULL);
        if(ret < 0)
        {
            perror("pthread_create");
            return 0;
        }
    }

    //主线程等待工作线程
    for(int i = 0; i < THREAD_COUNT; i++)
    {
        pthread_join(eat[i],NULL);
        pthread_join(make[i],NULL);
    }

    //销毁互斥锁
    pthread_mutex_destroy(&g_lock);
    //销毁条件变量
    pthread_cond_destroy(&g_eat_cond);
    pthread_cond_destroy(&g_make_cond);
    return 0;
}

在这里插入图片描述
程序正常，达到了预期的效果！

到这里，多线程安全篇的相关内容就告一段落了~，感觉本文有所帮助的读友们记得多多评论、转发！分享给身边的朋友们！！！
在这里插入图片描述

Suk-god
关注
  • 10
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 10
    评论
专栏目录
linux 多线程安全定时器
08-16
在Linux系统中，多线程编程常常涉及到时间管理和同步，以确保程序的高效与正确运行。`timerfd`和`epoll`是两种常见的机制，它们在处理多...了解并掌握这些知识，可以帮助开发者编写出更高效、更稳定的多线程Linux应用。
linux线程同步
06-13
介绍了linux线程同步的所有方式，包括互斥、自旋、信号量、条件变量等技术
unix_linux线程安全问题
07-18
里面主要是对unix_linux线程编程中的安全隐患的详细讨论！
linux c 多线程安全日志系统
04-29
在Linux C环境中，多线程安全日志系统是一种常见的需求，尤其在服务器应用程序中，它能够确保在高并发环境下正确地记录系统事件。本项目利用线程锁、信号量和文件操作技术，构建了一个安全的日志系统，同时考虑了...
Linux线程的实质
02-23
线程与进程的比较进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位.线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本...
Windows 下的sqlserver数据拷贝到linux
cyw8998的专栏
07-25 292
2.在 >1 提示符下，输入以下 RESTORE DATABASE 命令，并在每行后按 Enter（无法同时复制和粘贴整个多行命令）。将出现的所有 gpdb 替换为数据库的名称。1.启动 sqlcmd。下面的示例以 SA 用户身份连接到本地 SQL Server。出现提示时输入密码，或使用 -P 参数指定密码。SSH打开linux终端。
Linux玩转指南
qq_43535970的博客
07-25 840
Linux是一个类Unix操作系统，最初由Linus Torvalds于1991年发布。它是基于开源的内核，并结合了大量的开源软件，形成了完整的操作系统。Linux的设计理念强调开源和自由，使得它在全球范围内得到广泛应用，从个人电脑到服务器、嵌入式系统，甚至超级计算机。
Linux初学基本命令
yuan20010401的博客
07-25 628
1、rm 文件名称 删除多个文件多个目录需要用空格 删除根目录（rm -rf /*）1、touch 文件名字 用于linux创建文件 创建多个目录需要用空格隔开。2、mkdir 目录名称 用于创建文件夹 创建多个嵌套文件夹需要用/隔开。1、cp 当前文件 其他目录名称 拷贝文件夹需要在最后 -r。退出不保存时按Esc+:q!1、ls 查看当前目录下面的文件或者文件夹。2、more 文件名称 查看文件更多内容。1、mv 原文件路径 目标文件路径。退出保存时按Esc + :wq。
【linux】Shell脚本三剑客之grep和egrep命令的详细用法攻略
景天科技苑
07-25 4421
在Linux和Unix系统中，grep（Global Regular Expression Print）是一个非常强大的文本搜索工具，能够根据用户指定的模式（由正则表达式和文本字符组合而成）对目标文件进行逐行搜索，并显示匹配到的行。而egrep（Extended Grep）则是`grep`的扩展版本，支持更多的正则表达式语法。尽管egrep在较新的系统中被`grep -E`选项所取代，但了解其用法对于理解和使用正则表达式仍然具有重要意义。
Linux 常用命令分类及示例
简介
07-25 923
【代码】Linux 常用命令分类及示例。
electron TodoList网页应用打包成linux deb、AppImage应用
weixin_42357472的博客
07-25 683
这里用的是windows的wsl的ubuntu环境electron应用打包linux应用需要linux下打包，这里用windows的wsl的ubuntu环境进行操作。
【C语言】Linux 飞翔的小鸟
Minuhy
07-22 862
在Linux下运行的，用C语言编写的飞翔的小鸟，一款挺无聊的小游戏，分享给大家~
60个常见的 Linux 指令
yatingliu的博客
07-25 1375
是 “substitute user” 或 “switch user” 的缩写，它可以让你切换到另一个用户账户，包括 root 用户。是 “manual” 的缩写，通过它你可以访问系统的手册页（manual pages），这些手册页提供了详细的使用说明和参考信息。在一些 Linux 发行版中，adduser 是 useradd 的一个友好封装，功能上类似但提供了更多的默认设置和提示。-f, --force：强制删除，不提示错误信息，即使文件不存在也不会报错。：设置密码过期时间，单位为天。
Linux 使用技巧及示例
简介
07-25 745
【代码】Linux 使用技巧及示例。
安装nfs和rpcbind设置linux服务器共享磁盘
kaopuzong的博客
07-25 584
linux服务器安装nfs和rpcbind设置共享目录
【Android】linux
北冥有渔的博客
07-24 821
android系统就是跑在linux上的系统。Linux层里面包含系统和硬件驱动等一些本地代码的环境。linux的目录如果发现有ro，就重新mount，或者umount以后再remount如果发现有提示“device is busy”，找到是什么进程使得他busy将会显示使用这个模块的pid将会直接kill那个pid然后重新mount即可。还有一种方法是直接remount，。如何查看cpu占用状态?
【日常记录-Docker】Alibaba Cloud Linux3镜像
zhaoyaxuan001的博客
07-25 447
Alibaba Cloud Linux是一款由阿里云研发的稳定、安全、高性能的Linux服务器操作系统，为用户在Web服务、云原生应用、大数据、数据库、AI等场景部署中提供系统软件的维护、安全加固、性能优化、多架构支持、内核热补丁等操作系统服务。
『 Linux 』信号的写入与保存
小侯宝的博客
07-25 1175
忽略表示已经收到了该信号且已经对信号进行了处理,信号已经递达,其中信号的处理方式为忽略,即不作任何处理;信号递达指已经到达并被处理的信号,当信号处理程序执行完毕后这些信号就会被认定是已抵达的;信号递达表示信号已经被处理,进程将继续其正常执行流程或者根据信号类型执行特定行为;阻塞表示已经收到了该信号但不对信号进行处理,使得信号在取消阻塞前都保持未决状态;被阻塞的信号产生时将保持在未决状态,直到进程解除对此信号的阻塞才执行递达动作;信号集被传进接口函数并对原有阻塞信号集进行操作时将会将原本的阻塞信号集写入。
实现一个全栈模糊搜索匹配的功能
最新发布
前端原创分享，常年坚持记录和分享，全网阅读量超百万
07-27 367
提供一个全栈实现的方案，包括 Vue 3 前端、Express 后端和 MySQL 数据库的分类模糊搜索功能。
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Suk-god

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值