【关于Linux中----线程互斥】

这篇具有很好参考价值的文章主要介绍了【关于Linux中----线程互斥】。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。


一、线程互斥

1.1互斥概念的引入

先来用代码模拟一个抢票的场景,四个线程不停地抢票,一共有1000张票,抢完为止,代码如下:

#include <iostream>
#include <pthread.h>
#include <string>
#include <unistd.h>
#include <cstdio>
#include <cstring>
#include <memory>

int tickets=1000;

void* get_ticket(void* args)
{
    std::string username=static_cast<const char*>(args);
    while(true)
    {
        if(tickets>0)
        {
            usleep(1000);//用来模拟抢票花费时间
            std::cout<<username<<" 抢票ing"<<tickets<<std::endl;
            tickets--;
        }
        else
        {
            break;
        }
    }
    return nullptr;
}

int main()
{
    pthread_t t1,t2,t3,t4;
    pthread_create(&t1,nullptr,get_ticket,(void*)"线程1");
    pthread_create(&t2,nullptr,get_ticket,(void*)"线程2");
    pthread_create(&t3,nullptr,get_ticket,(void*)"线程3");
    pthread_create(&t4,nullptr,get_ticket,(void*)"线程4");

    pthread_join(t1,nullptr);
    pthread_join(t2,nullptr);
    pthread_join(t3,nullptr);
    pthread_join(t4,nullptr);
    return 0;
}

执行结果如下:

线程2 抢票ing线程4 抢票ing4
线程3 抢票ing2
4
线程1 抢票ing0
线程4 抢票ing-1
线程3 抢票ing-2
[sny@VM-8-12-centos threaddone]$

可以看到,最后出现了票数为负数的情况,很显然这是错误的,是不应该出现的。

为什么会出现这种情况?

首先要明确,上述的几个线程是不能同时执行抢票的动作的。
但是,这几个线程可以在执行的过程中不断地切换,即当一个线程还没有执行完抢票的动作的时候,就可以被另一个线程切走。
而众所周知,进行计算操作时,数据要被加载到CPU中进行运算,之后再写回内存中,并且CPU中的寄存器只有一套,每一个线程离开CPU时,要将寄存器中的属于自己的上下文带走,到下一次执行时再将上下文数据写回CPU中进行没有完成的操作。

所以,当一个线程准备抢票时,却突然被另一个线程切走。这时,该线程的上下文记录中,tickets是大于0的,但是很有可能另一个线程已经把票抢完了。所以,该线程再一次运行时,就会误以为tickets>0,再次抢票,就出现了票数为负数的情况。

所以,当我们定义全局变量,且有多个线程执行时,该变量很有可能是不安全的

这里再补充几个概念:

  • 多个执行流进行安全访问的共享资源叫做临界资源
  • 多执行流中,访问临界资源的代码叫做临界区(往往是线程代码中很小的一部分)
  • 让多个线程串行访问共享资源叫做互斥
  • 对一个资源进行访问时,要么不做,要么做完(原子性----一个对资源进行的操作,如果只用一条汇编代码就能完成,就称它为原子的)

所以,为了能保证共享资源的安全性,就要进行一个加锁的操作:
【关于Linux中----线程互斥】
对资源访问结束后,再进行解锁操作。


1.2详解互斥量

1.2.1对样例代码加锁

先二话不说,用锁对上面的代码中的临界资源做保护,随后再解释原理,代码如下:

int tickets=1000;

class ThreadData
{
public:
    ThreadData(const std::string threadname,pthread_mutex_t* mutex_P)
        :threadname_(threadname)
        ,mutex_p_(mutex_P)
    {}

    ~ThreadData()
    {}
public:
    std::string threadname_;
    pthread_mutex_t* mutex_p_;
};

void* get_ticket(void* args)
{
    ThreadData* td=static_cast<ThreadData*>(args);
    while(true)
    {
        pthread_mutex_lock(td->mutex_p_);//加锁
        if(tickets>0)
        {
            usleep(1000);//用来模拟抢票花费时间
            std::cout<< td->threadname_<<" 抢票ing"<<tickets<<std::endl;
            tickets--;
            pthread_mutex_unlock(td->mutex_p_);//解锁
        }
        else
        {
            pthread_mutex_unlock(td->mutex_p_);
            break;
        }
    }
    return nullptr;
}

int main()
{
#define NUM 4
    pthread_mutex_t lock;
    pthread_mutex_init(&lock,nullptr);//初始化锁
    std::vector<pthread_t> tids(NUM);
    for(int i=0;i<NUM;i++)
    {
        char buffer[64];
        snprintf(buffer,sizeof(buffer),"thread %d",i+1);
        ThreadData* td=new ThreadData(buffer,&lock);
        pthread_create(&tids[i],nullptr,get_ticket,td);
    }

    for(const auto& tid:tids)
    {
        pthread_join(tid,nullptr);
    }

    pthread_mutex_destroy(&lock);//销毁锁
    return 0;
}

运行结果如下:

thread 4 抢票ing4
thread 4 抢票ing3
thread 4 抢票ing2
thread 4 抢票ing1
[sny@VM-8-12-centos threaddone]$ 

可以看到,这次抢票的结果没有出现负数的情况,但是,这次只有线程4在抢票,这是因为锁只规定互斥访问,没有规定谁优先执行,锁就是让多个执行流进行竞争的结果。而且,由于加锁之后,所有线程是串行的,所以这次运行速度会慢一些。

当然,抢票结束之后还要让每一个执行流去做自己的事,这样其他执行流就也可以抢到票了,让每个线程抢完票之后usleep一段时间用来模拟实现其他业务。

1.2.2如何看待锁?

上文中定义的tickets是一个全局变量,为保护全局变量就要加锁。但是每一个线程访问全局变量之前都要访问锁,所以锁本身就是一个全局变量,那锁的安全怎么保护?

加锁的过程是原子的,所以加锁和解锁的过程是十分安全的。

如果一个执行流申请锁失败怎么办?----答案是执行流会阻塞,直到它被唤醒。

举个例子:

while(true)
{
    pthread_mutex_lock(td->mutex_p_);//加锁
    pthread_mutex_lock(td->mutex_p_);//加锁
    if(tickets>0)
    {
        usleep(1000);//用来模拟抢票花费时间
        std::cout<< td->threadname_<<" 抢票ing"<<tickets<<std::endl;
        tickets--;
        pthread_mutex_unlock(td->mutex_p_);//解锁
    }
    else
    {
        pthread_mutex_unlock(td->mutex_p_);
        break;
    }
}

如上,对每一个线程申请锁成功之后再一次申请,就必定会失败。
运行结果如下:
【关于Linux中----线程互斥】
可以看到,四个线程是存在的,但是它们都处于阻塞状态。直到该线程现在持有的锁释放,操作系统才会唤醒该线程,让它继续持有下一个锁并向后执行。

也可以使用pthread_mutex_trylock
【关于Linux中----线程互斥】
这个接口可以判断当前线程有没有持有锁,没有就申请一个锁并返回,有就直接返回,不会造成阻塞的问题。

根据以上内容,不难判断,只有持有锁的线程才可以访问临界区!

还要注意几点:

  • 如果一个线程申请锁成功并且正在访问临界资源,其他线程会处于阻塞状态
  • 如果一个线程申请锁成功并且正在访问临界资源,该线程可以被其他线程切换
  • 当持有锁的线程被切走,其他线程依旧无法申请锁,也就无法访问临界资源,不能向后执行,直到持有锁的线程释放锁
  • 对于一个线程,有意义的状态只有持有锁和释放锁两种状态。站在其他线程角度,该线程持有锁的过程就是原子的

1.2.3如何理解加锁的本质

上文中说了加锁和解锁是原子性的,那么这个过程是怎么实现原子性的呢?

当我们对汇编代码稍有了解之后,就会知道即便是非常简单的诸如i++/i–这样的运算,都不可能只用一条汇编代码就能完成。对于这种不能“瞬间”完成的非原子性的运算,在多线程环境下,很可能被其他线程中断并修改数据,导致数据错误。

为了实现互斥锁操作,大多数体系结构都提供了swap或exchange指令,该指令的作用是把寄存器和内存单元的数据想交换,由于只有一条指令,保证了原子性,即使是多处理器平台,访问内存的总线周期也有先后,一个处理器上的交换指令执行时,另一个处理器的交换指令只能等待总线周期。

以上便可实现加锁和解锁的原子性。


三、对锁进行封装

封装过程比较简单,直接上代码:

#pragma once
#include <iostream>
#include <pthread.h>

class Mutex
{
public:
    Mutex(pthread_mutex_t* lock_P=nullptr):lock_p_(lock_P)
    {}

    void lock()
    {
        if(lock_p_) pthread_mutex_lock(lock_p_);
    }

    void unlock()
    {
        if(lock_p_) pthread_mutex_unlock(lock_p_);
    }

    ~Mutex()
    {}
private:
    pthread_mutex_t* lock_p_;
};

class LockGuard
{
public:
    LockGuard(pthread_mutex_t* mutex) :mutex_(mutex)
    {
        mutex_.lock();//在构造函数中加锁
    }
    ~LockGuard()
    {
        mutex_.unlock();//在析构函数中解锁
    }
private:
    Mutex mutex_;
};

加锁时,就只需要创建一个锁变量,并将其传递给LockGuard对象即可自动初始化,是用完之后会自动销毁。使用比较简单,这里就不演示了。


四、可重入和线程安全

4.1概念

  • 线程安全:多个线程并发同一段代码时,不会出现不同的结果。常见对全局变量或者静态变量进行操作,并且没有锁保护的情况下,会出现该问题。
  • 重入:同一个函数被不同的执行流调用,当前一个流程还没有执行完,就有其他的执行流再次进入,我们称之为重入。一个函数在重入的情况下,运行结果不会出现任何不同或者任何问题,则该函数被称为可重入函数,否则,是不可重入函数。

4.2常见线程安全和不安全的情况

常见线程不安全的情况:

  • 不保护共享变量的函数
  • 函数状态随着被调用,状态发生变化的函数
  • 返回指向静态变量指针的函数
  • 调用线程不安全函数的函数

常见线程安全的情况:

  • 每个线程对全局变量或者静态变量只有读取的权限,而没有写入的权限,一般来说这些线程是安全的
  • 类或者接口对于线程来说都是原子操作
  • 多个线程之间的切换不会导致该接口的执行结果存在二义性

4.3常见可重入和不可重入的情况

常见不可重入的情况:

  • 调用了malloc/free函数,因为malloc函数是用全局链表来管理堆的
  • 调用了标准I/O库函数,标准I/O库的很多实现都以不可重入的方式使用全局数据结构
  • 可重入函数体内使用了静态的数据结构

常见可重入的情况:

  • 不使用全局变量或静态变量
  • 不使用用malloc或者new开辟出的空间
  • 不调用不可重入函数
  • 不返回静态或全局数据,所有数据都有函数的调用者提供
  • 使用本地数据,或者通过制作全局数据的本地拷贝来保护全局数据

4.4可重入与线程安全的联系

  • 函数是可重入的,那就是线程安全的
  • 函数是不可重入的,那就不能由多个线程使用,有可能引发线程安全问题
  • 如果一个函数中有全局变量,那么这个函数既不是线程安全也不是可重入的。

4.5可重入和线程安全的区别

  • 可重入函数是线程安全函数的一种
  • 线程安全不一定是可重入的,而可重入函数则一定是线程安全的。
  • 如果将对临界资源的访问加上锁,则这个函数是线程安全的,但如果这个重入函数若锁还未释放则会产生死锁,因此是不可重入的。

五、死锁

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

用大白话来理解上面这句话就是,在多把锁的场景下,每一个执行流都持有自己的锁,在不释放的情况下,还想申请其他执行流的锁,其他的执行流也是这样的情况,这时就造成了死锁的情况。

形成死锁的四个必要条件:

①互斥:一个资源每次只能被一个执行流使用
②请求与保持:一个执行流因请求资源而阻塞时,对已获得的资源保持不放
③不剥夺:一个执行流已获得的资源,在末使用完之前,不能强行剥夺
④循环等待:若干执行流之间形成一种头尾相接的循环等待资源的关系

怎么解决死锁?

上述四个是形成死锁的必要条件,所以解决死锁只需要破坏上述任意一个条件即可。
首先,申请锁一定是为了互斥访问资源,所以这个条件一定是成立的,无法破坏。
其次,对于第二个条件。如果一个执行流已经申请到了锁,还想申请下一个,可以采用一定策略使得这次申请失败,或者释放原来的锁,再申请下一个锁,如此便可解决请求与保持的问题。
再次,当多个执行流不能剥夺其他执行流的锁时,我们可以设置一个比较策略,比较出在某一方面较差的一个执行流,让其主动交出自己持有的锁即可。
最后,可以通过控制线程申请锁的顺序,来避免环路等待的问题。

常见的两种解决死锁的算法:

①死锁检测算法
②银行家算法
看兴趣的读者可以通过这两个链接了解一下。


本篇完,下一篇为【关于Linux中----线程同步】,敬请期待!文章来源地址https://www.toymoban.com/news/detail-418081.html

到了这里,关于【关于Linux中----线程互斥】的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 『Linux』第九讲:Linux多线程详解(三)_ 线程互斥 | 线程同步

    「前言」文章是关于Linux多线程方面的知识,上一篇是 Linux多线程详解(二),今天这篇是 Linux多线程详解(三),内容大致是线程互斥与线程同步,讲解下面开始! 「归属专栏」Linux系统编程 「主页链接」个人主页 「笔者」枫叶先生(fy) 「枫叶先生有点文青病」「每篇一句

    2024年02月02日
    浏览(70)
  • 【Linux】线程同步和互斥

    1.临界资源:多线程执行流共享的资源,且一次只能允许一个执行流访问的资源就叫做临界资源。(多线程、多进程打印数据) 2.临界区:每个线程内部,访问临界资源的代码,就叫做临界区。 3.互斥:任何时刻,互斥保证有且只有一个执行流进入临界区,访问临界资源,通常对

    2024年02月08日
    浏览(42)
  • linux:线程互斥

    个人主页 : 个人主页 个人专栏 : 《数据结构》 《C语言》《C++》《Linux》 本文是对于线程互斥的知识总结 我们先看下面代码。 该代码创建三个线程-1,线程-2,线程-3,去抢夺ticket资源,当ticket从10000依次减到0时,三个线程退出。那该代码运行结果是什么呢?ticket最后会是

    2024年03月21日
    浏览(38)
  • Linux->线程互斥

    前言: 1 线程互斥 1.1 多线程并发问题 1.2 线程锁 1.3 锁的接口 2 线程安全与可重入函数  3 死锁         本篇文章主要讲解了线程互斥的实现方式,还有原理,并附上代码讲解。并且讲解了锁的概念,问题等。         还记得我上一篇文章的结尾有提过的问题吗?如果多个

    2024年02月10日
    浏览(38)
  • Linux多线程互斥锁

    迷途小书童的 Note 读完需要 5 分钟 速读仅需 2 分钟 1 引言 在 Linux 编程中,多线程是一种常见的并发编程模型。为了保证多线程之间的数据同步和互斥访问,pthread_mutex(互斥锁)是一个重要的工具。本文将深入探讨 pthread_mutex 的底层实现原理、函数原型,并提供详细的使用方

    2024年02月10日
    浏览(52)
  • Linux之线程互斥

    目录 一、问题引入 二、线程互斥 1、相关概念 2、加锁保护 1、静态分配 2、动态分配 3、锁的原理 4、死锁 三、可重入与线程安全 1、概念 2、常见的线程不安全的情况 3、常见的线程安全的情况 4、常见不可重入的情况 5、常见可重入的情况 6、可重入与线程安全联系 7、可重

    2024年03月16日
    浏览(87)
  • 【linux】线程互斥

    喜欢的点赞,收藏,关注一下把! 到目前为止我们学了线程概念,线程控制接下来我们进行下一个话题,线程互斥。 有没有考虑过这样的一个问题,既然 线程一旦被创建,几乎所有资源都是被所有线程共享的。 那多个线程访问同一份共享资源有没有什么问题? 下面我们模

    2024年02月03日
    浏览(39)
  • Linux--线程--互斥锁

    1.互斥量 a)互斥量(mutex)从本质上来说是一把锁,一般在主线程中定义一个互斥量,就是定义一把锁。然后根据我们的需求来对线程操作这把锁。 b)如果给所有的线程都加上锁了,线程们会去争取内存空间,谁先争取到谁先运行,直到该线程解锁后,期间其他线程只能等

    2024年02月06日
    浏览(42)
  • 【Linux】多线程2——线程互斥与同步/多线程应用

    💭上文主要介绍了多线程之间的独立资源,本文将详细介绍多线程之间的 共享资源 存在的问题和解决方法。 intro 多线程共享进程地址空间,包括创建的全局变量、堆、动态库等。下面是基于全局变量实现的一个多线程抢票的demo。 发现错误:线程抢到负数编号的票,为什么

    2024年02月10日
    浏览(42)
  • 【探索Linux】—— 强大的命令行工具 P.20(多线程 | 线程互斥 | 互斥锁 | 死锁 | 资源饥饿)

    在上一篇文章中,我们对多线程编程的基础知识进行了深入的探讨,包括了线程的概念、线程控制以及分离线程等关键点。通过这些内容的学习,我们已经能够理解并实现简单的多线程程序。然而,随着程序复杂度的提升,仅仅掌握这些基础是远远不够的。在多线程环境下,

    2024年02月05日
    浏览(41)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包