Linux线程安全篇Ⅱ

Posted Suk-god

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Linux线程安全篇Ⅱ相关的知识,希望对你有一定的参考价值。

文章目录

0、接上篇

线程安全

1、同步存在的必要性

1.1 样例引入

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

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

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

将上述情景翻译为线程相关的描述就是:
有一个全局的临界资源g_bowl,其中g_bowl = 1表示有面, g_bowl = 0表示没面。有两个线程A和BA是一个做面线程,只负责向碗里做面,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;
Linux线程安全篇Ⅰ

Java并发/多线程系列——线程安全篇

Java并发/多线程系列——线程安全篇

Web安全篇学习笔记1

Linux修改SSH远程登录端口 --服务器安全篇

Linux 多线程:线程安全之同步与互斥的理解