Linux线程互斥

  • 开发
  • 18

1.用线程封装代码测试通过现象引出线程互斥

1.1代码测试

Thread.hpp

#pragma once
#include<iostream>
#include<string>
#include<functional>
#include<pthread.h>
template<class T>
using func_t = std::function<void(T)>;

template<class T>
class Thread
{
public:
    Thread(const std::string & threadname,func_t<T> func,T data)
        :_tid(0)
        ,_isrunning(false)
        ,_threadname(threadname)
        ,_func(func)
        ,_data(data)
    {}

    static void* ThreadRoutine(void * args)
    {
        Thread* ts =static_cast<Thread*>(args);
        ts->_func(ts->_data);

        return nullptr;
    }

    bool Start()
    {
        int n = pthread_create(&_tid,nullptr,ThreadRoutine,this);
        if(n==0)
        {
            _isrunning = true;
            return true;
        }
        return false;
    }

    bool Join()
    {
        if(!_isrunning) return true;
        int n = pthread_join(_tid,nullptr);
        if(n==0)
        {
            _isrunning = false;
            return true;
        }
        return false;
    }   

    std::string ThreadName()
    {
        return _threadname;
    }

    bool IsRunning()
    {
        return _isrunning;
    }

    ~Thread()
    {}

private:
    pthread_t _tid;
    bool _isrunning;
    std::string _threadname;
    func_t<T> _func;
    T _data;
};

main.cc

#include<iostream>
#include<string> 
#include<unistd.h>
#include"Thread.hpp"

std::string GetThreadName()
{
    static int num = 1;
    char name[64];
    snprintf(name,sizeof(name),"Thread-%d",num++);
    return name;
}

void Print(int num)
{
    while(num)
    {
        std::cout<<"hello world: "<<num--<<std::endl;
        sleep(1);
    }
}

int ticket = 10000;//全局的共享资源

void GetTicket(std::string name)
{
    while(true)
    {
        if(ticket>0)
        {
            usleep(1000);
            printf("%s get a ticket: %d\n",name.c_str(),ticket);
            ticket--;
        }
        else 
        {
            break;
        }
    }
}

int main()
{
    std::string name1 = GetThreadName();
    Thread<std::string>t1(name1,GetTicket,name1);

    std::string name2 = GetThreadName();
    Thread<std::string>t2(name2,GetTicket,name2);

    std::string name3 = GetThreadName();
    Thread<std::string>t3(name3,GetTicket,name3);

    std::string name4 = GetThreadName();
    Thread<std::string>t4(name4,GetTicket,name4);

    t1.Start();
    t2.Start();
    t3.Start();
    t4.Start();

    t1.Join();
    t2.Join();
    t3.Join();
    t4.Join();


    return 0;
}

运行结果：

1.2概念引入

在这次测试当中我们发现票数出现了负数，然而当我们真正现实生活中电影院抢票或者高铁飞机抢票有多少个位置它就卖多少张票，而不可能多卖票，否则座位会产生冲突，所以这里票数出现了负数说明多卖出去了几张票，所以票数卖到负数是不合理的。我们把这种情况叫做数据不一致，所以对于这部分共享资源为了防止出现数据不一致的情况，我们是要把这部分共享资源保护起来的，怎么保护呢？我们只需要保证任何一个时刻只允许一个线程正在访问共享资源。被保护起来的资源我们叫做临界资源。我们把访问临界资源的代码叫做临界区。

  • 临界资源：多线程执行流共享的资源就叫做临界资源
  • 临界区：每个线程内部，访问临界资源的代码，就叫做临界区
  • 互斥：任何时刻，互斥保证有且只有一个执行流进入临界区，访问临界资源，通常对临界资源起保护作用
  • 原子性：不会被任何调度机制打断的操作，该操作只有两态，要么完成，要么未完成。

1.3解释原因

下面我们看一段简单的反汇编代码：

其实一条简单的a++指令是需要三条汇编语句的。其实第一步就是先从内存中将a拷贝到CPU的寄存器当中然后第二步是通过计算对a进行++,第三步是把CPU寄存器a++后的值拷贝回内存中的。

而一般情况是将一条汇编语句看作原子性。多线程并发访问全部int,不是原子的会有数据不一致的并发访问问题。

而同理

这段代码也同上述一样，ticket--;也是通过执行三条汇编语句，不是原子的。而判断本身也是计算，也就是if(ticket>0)这条语句。而CPU大概总结下来分四种功能：

算术运算，逻辑运算，处理内外中断，控制单元。

通过上述的说法，那么就会有这样一种情况，当我们的四个线程都在通过if判断之后进入到临界区，此时ticket=1;那么在时间片到之后进行了切换，然后四个线程依次执行ticket--操作，所以就会导致ticket=1时被4个线程减4次，导致减到了-2这种情况。因为数据在内存中，本质是被线程共享的，数据被读取到寄存器中，本质变成了线程的上下文，属于线程私有数据。

而如何对这种共享资源进行保护呢？通过加锁。

2.理解锁

2.1认识接口

初始化互斥量
初始化互斥量有两种方法：

方法1，静态分配:
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER；

方法2，动态分配:
int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict
attr);
参数：
mutex：要初始化的互斥量
attr：NULL

销毁互斥量需要注意：

  • 使用 PTHREAD_ MUTEX_ INITIALIZER 初始化的互斥量不需要销毁
  • 不要销毁一个已经加锁的互斥量
  • 已经销毁的互斥量，要确保后面不会有线程再尝试加锁

互斥量加锁和解锁

int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
返回值:成功返回0,失败返回错误号

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

  • 互斥量处于未锁状态，该函数会将互斥量锁定，同时返回成功
  • 发起函数调用时，其他线程已经锁定互斥量，或者存在其他线程同时申请互斥量，但没有竞争到互斥量，那么pthread_ lock调用会陷入阻塞(执行流被挂起)，等待互斥量解锁。

对临界区进行加锁：

1.我们要尽可能的给少的代码块加锁

2.一般加锁都是给临界区加锁

这里的锁也是全局变量，所以也是共享资源，而申请锁本身安全吗？申请锁本身是安全的，因为他是原子的。

运行结果：

我们发现执行速度变慢了，但是没有出现负数的情况了。

根据互斥的定义，任何时刻只允许一个线程申请锁成功，多个线程申请锁失败，失败的线程怎么办？在mutex上进行阻塞，本质就是等待。

一个线程在临界区中访问临界资源的时候是可能会发生切换的。

除了把锁定义为全局的，还可以将锁定义成局部的，定义局部的锁需要用到这个pthread_mutex_init这个接口来进行初始化，用phtread_mutex_destroy来销毁：

2.2用锁解决问题

要解决以上问题，需要做到三点：

  • 代码必须要有互斥行为：当代码进入临界区执行时，不允许其他线程进入该临界区。
  • 如果多个线程同时要求执行临界区的代码，并且临界区没有线程在执行，那么只能允许一个线程进入该临界区。
  • 如果线程不在临界区中执行，那么该线程不能阻止其他线程进入临界区。

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

将代码进行部分修改：

main.cc

#include<iostream>
#include<string> 
#include<unistd.h>
#include"Thread.hpp"

std::string GetThreadName()
{
    static int num = 1;
    char name[64];
    snprintf(name,sizeof(name),"Thread-%d",num++);
    return name;
}

void Print(int num)
{
    while(num)
    {
        std::cout<<"hello world: "<<num--<<std::endl;
        sleep(1);
    }
}

int ticket = 10000;//全局的共享资源
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;


void GetTicket(pthread_mutex_t* mutex)
{
    while(true)
    {
        pthread_mutex_lock(mutex);
        if(ticket>0)
        {
            usleep(1000);
            printf("get a ticket: %d\n",ticket);
            ticket--;
            pthread_mutex_unlock(mutex);

        }
        else 
        {
            pthread_mutex_unlock(mutex);
            break;
        }
    }
}

int main()
{
    pthread_mutex_t mutex;
    pthread_mutex_init(&mutex,nullptr);
    std::string name1 = GetThreadName();
    Thread<pthread_mutex_t *>t1(name1,GetTicket,&mutex);

    std::string name2 = GetThreadName();
    Thread<pthread_mutex_t *>t2(name2,GetTicket,&mutex);

    std::string name3 = GetThreadName();
    Thread<pthread_mutex_t *>t3(name3,GetTicket,&mutex);

    std::string name4 = GetThreadName();
    Thread<pthread_mutex_t *>t4(name4,GetTicket,&mutex);

    t1.Start();
    t2.Start();
    t3.Start();
    t4.Start();

    t1.Join();
    t2.Join();
    t3.Join();
    t4.Join();
 
    pthread_mutex_destroy(&mutex);
    return 0;
}

Thread.hpp

#pragma once
#include<iostream>
#include<string>
#include<functional>
#include<pthread.h>
template<class T>
using func_t = std::function<void(T)>;

template<class T>
class Thread
{
public:
    Thread(const std::string & threadname,func_t<T> func,T data)
        :_tid(0)
        ,_isrunning(false)
        ,_threadname(threadname)
        ,_func(func)
        ,_data(data)
    {}

    static void* ThreadRoutine(void * args)
    {
        Thread* ts =static_cast<Thread*>(args);
        ts->_func(ts->_data);

        return nullptr;
    }

    bool Start()
    {
        int n = pthread_create(&_tid,nullptr,ThreadRoutine,this);
        if(n==0)
        {
            _isrunning = true;
            return true;
        }
        return false;
    }

    bool Join()
    {
        if(!_isrunning) return true;
        int n = pthread_join(_tid,nullptr);
        if(n==0)
        {
            _isrunning = false;
            return true;
        }
        return false;
    }   

    std::string ThreadName()
    {
        return _threadname;
    }

    bool IsRunning()
    {
        return _isrunning;
    }

    ~Thread()
    {}

private:
    pthread_t _tid;
    bool _isrunning;
    std::string _threadname;
    func_t<T> _func;
    T _data;
};

运行结果：

一样可以解决票数减到负数的情况，只不过执行变慢了，因为执行临界区的代码那几个线程都是通过串行执行的。

下面我们添加一些代码对锁进行简单的封装：

LockGuard.hpp

#pragma once
#include<pthread.h>


//不定义锁，默认认为外部会给我们传入锁对象
class Mutex
{
public:
    Mutex(pthread_mutex_t * lock):_lock(lock)
    {}

    void Lock()
    {
        pthread_mutex_lock(_lock);
    }

    void Unlock()
    {
        pthread_mutex_unlock(_lock);
    }


    ~Mutex(){}

private:
    pthread_mutex_t * _lock;
};

class LockGuard
{
public:
    LockGuard(pthread_mutex_t * lock):_mutex(lock)
    {
        _mutex.Lock();
    }

    ~LockGuard()
    {
        _mutex.Unlock();
    }

private:
    Mutex _mutex;
};

main.cc

#include<iostream>
#include<string> 
#include<unistd.h>
#include"Thread.hpp"
#include"LockGuard.hpp"
std::string GetThreadName()
{
    static int num = 1;
    char name[64];
    snprintf(name,sizeof(name),"Thread-%d",num++);
    return name;
}

void Print(int num)
{
    while(num)
    {
        std::cout<<"hello world: "<<num--<<std::endl;
        sleep(1);
    }
}

int ticket = 10000;//全局的共享资源
//pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
class ThreadData
{
public:
    ThreadData(const std::string & name,pthread_mutex_t* lock)
    : threadname(name)
    ,pmutex(lock)
    {}

    pthread_mutex_t * getPmutex()
    {
        return this->pmutex;
    }

    void setPmutex(pthread_mutex_t * mutex)
    {
        this->pmutex = mutex;
    }

    std::string getName()
    {
        return this->threadname;
    }

    void setName(std::string name)
    {
        this->threadname = name;
    }


private:
    std::string threadname;
    pthread_mutex_t * pmutex;
};

void GetTicket(ThreadData* td)
{
    while(true)
    {
        LockGuard lockguard(td->getPmutex());
        //pthread_mutex_lock(mutex);
        if(ticket>0)
        {
            usleep(1000);
            printf("%s get a ticket: %d\n",td->getName().c_str(),ticket);
            ticket--;
            //pthread_mutex_unlock(mutex);

        }
        else 
        {
            //pthread_mutex_unlock(mutex);
            break;
        }
    }
}



int main()
{
    pthread_mutex_t mutex;
    pthread_mutex_init(&mutex,nullptr);

    std::string name1 = GetThreadName();
    ThreadData* td1 = new ThreadData(name1,&mutex);
    Thread<ThreadData*>t1(name1,GetTicket,td1);

    std::string name2 = GetThreadName();
    ThreadData* td2 = new ThreadData(name2,&mutex);
    Thread<ThreadData*>t2(name2,GetTicket,td2);

    std::string name3 = GetThreadName();
    ThreadData* td3 = new ThreadData(name3,&mutex);
    Thread<ThreadData*>t3(name3,GetTicket,td3);

    std::string name4 = GetThreadName();
    ThreadData* td4 = new ThreadData(name4,&mutex);
    Thread<ThreadData*>t4(name4,GetTicket,td4);

    t1.Start();
    t2.Start();
    t3.Start();
    t4.Start();

    t1.Join();
    t2.Join();
    t3.Join();
    t4.Join();
    
    pthread_mutex_destroy(&mutex);
    delete td1;
    delete td2;
    delete td3;
    delete td4;
    return 0;
}

thread.hpp

#pragma once
#include<iostream>
#include<string>
#include<functional>
#include<pthread.h>
template<class T>
using func_t = std::function<void(T)>;

template<class T>
class Thread
{
public:
    Thread(const std::string & threadname,func_t<T> func,T data)
        :_tid(0)
        ,_isrunning(false)
        ,_threadname(threadname)
        ,_func(func)
        ,_data(data)
    {}

    static void* ThreadRoutine(void * args)
    {
        Thread* ts =static_cast<Thread*>(args);
        ts->_func(ts->_data);

        return nullptr;
    }

    bool Start()
    {
        int n = pthread_create(&_tid,nullptr,ThreadRoutine,this);
        if(n==0)
        {
            _isrunning = true;
            return true;
        }
        return false;
    }

    bool Join()
    {
        if(!_isrunning) return true;
        int n = pthread_join(_tid,nullptr);
        if(n==0)
        {
            _isrunning = false;
            return true;
        }
        return false;
    }   

    std::string ThreadName()
    {
        return _threadname;
    }

    bool IsRunning()
    {
        return _isrunning;
    }

    ~Thread()
    {}

private:
    pthread_t _tid;
    bool _isrunning;
    std::string _threadname;
    func_t<T> _func;
    T _data;
};

运行结果：

还是能够正常将票数减到1，但是我们发现一个问题，后面这么多张票都被Thread-3线程给抢了，多线程运行，同一份资源有线程长时间无法拥有，我们把这种现象称之为饥饿问题，单纯的互斥是解决不了的，要解决饥饿问题就要让线程执行的时候具备一定的顺序性---同步。

2.3理解锁

线程加锁的本质：

  • 经过上面的例子，大家已经意识到单纯的 i++ 或者 ++i 都不是原子的，有可能会有数据一致性问题
  • 为了实现互斥锁操作,大多数体系结构都提供了swap或exchange指令,该指令的作用是把寄存器和内存单元的数据相交换,由于只有一条指令,保证了原子性,即使是多处理器平台,访问内存的 总线周期也有先后,一个处理器上的交换指令执行时另一个处理器的交换指令只能等待总线周期。 现在我们把lock和unlock的伪代码改一下

这里的定义的mutex是内存级的，线程共享的，而寄存器硬件在CPU内只有一套，但是寄存器的内容有很多套，因为每一个线程都有一份属于自己的上下文！xchgb的作用：将一个共享的mutex资源交换到自己的上下文当中，属于线程自己！上述的指令每一条都是原子的，所以也就保证了加锁和解锁都是原子的。

阅读全部

相关推荐

最近更新

  4. TCP协议是安全的吗?

    2024-03-29 11:22:03       18 阅读

  12. 阿里云服务器执行yum，一直下载docker-ce-stable失败

    2024-03-29 11:22:03       19 阅读

  13. 【Python教程】压缩PDF文件大小

    2024-03-29 11:22:03       18 阅读

  18. 通过文章id递归查询所有评论（xml）

    2024-03-29 11:22:03       20 阅读

热门阅读

  5. MySql 常用的聚合函数

    2024-03-29 11:22:03       20 阅读
  6. 3.28C++

    3.28C++

    2024-03-29 11:22:03      17 阅读

  7. PHP radis 处理缓存简单示例

    2024-03-29 11:22:03       17 阅读

  9. vue状态管理

    2024-03-29 11:22:03       20 阅读

  10. chromium 源码学习笔记

    2024-03-29 11:22:03       18 阅读

  14. 自动化组高度件切割计算

    2024-03-29 11:22:03       23 阅读

  15. Docker学习指南

    2024-03-29 11:22:03       21 阅读

  16. 简述机器视觉技术在自动化行业中的典型应用

    2024-03-29 11:22:03       21 阅读

  17. 自动化更新包文件--shell脚本

    2024-03-29 11:22:03       20 阅读

  20. 如何本地使用SCP/SSH命令连接远程主机而无需输入密码

    2024-03-29 11:22:03       17 阅读

  24. Go打造REST Server【四】：Graphql进阶

    2024-03-29 11:22:03       17 阅读