博客

Linux线程篇（下）

  • Post author:
  • Post category:linux


有了之前对线程的初步了解我们学习了什么是线程，线程的原理及其控制。这篇文章将继续讲解关于线程的内容以及重要的知识点。

线程的


优缺点


：


线程的缺点

在这里我们来谈一谈线程


健壮性


：

首先我们先思考一个问题，如果一个线程出现了问题，那么它会影响其他线程吗？

我们写代码验证一下： 

#include <iostream>
#include <string>
#include <unistd.h>
using namespace std;


void* start_route(void* args)
{
    string name =static_cast<char*>(args);
    while(true)
    {
        cout<<"我是一个新线程，我的名字是："<<name<<endl;
        sleep(1);

    }

}


int main()
{

    pthread_t id;
    pthread_create(&id,nullptr,start_route,(void*)"thread one");
    while(true)
    {
        cout<<"我是主线程！！！！"<<endl;
        sleep(1);

    }

    return 0;



}

代码运行的结果如下：

我们用ps命令进行查看：

pid和lwp的值相同的是主线程 ，不一样的是创建出来的新线程。我们继续修改代码，使其中的一个线程崩溃，看看会不会影响另一个进程：

结果如下：

当我们再用ps命令进行查找时发现两个线程不复存在，原因是：当一个线程对野指针进行访问时，操作系统会发送信号终止


进程

，


而两个线程的pid相同，同属于一个进程，因此两个线程同时崩溃！

之前我们说过操作系统里面没有真正线程的概念，它只提供轻量级进程的使用接口，而创建进程或者线程底层调用的是

clone

：

这里我们了解一下底层使用的接口就行，我们还是使用平常用的fork和pthread_create创建。

如何看待线程库？（语言版）

#include <iostream>
#include <string>
#include <unistd.h>
#include <thread>

void* thread_run()
{
    while(true)
    {
        std::cout<<"我是一个新线程！！"<<std::endl;
    }


}

int main()
{
    std::thread t1(thread_run);
    while(true)
    {
        std::cout<<"我是主线程！！！"<<std::endl;
    }
    t1.join();
}

当我们用c++11中的线程时，不引入线程库时，程序运行报错：

错误显示有未被定义的“pthread_create”,由此可以看出在linux环境下，

c++语言中的线程本质是对linux底下线程库的进一步封装

。

上面的代码也能在windows底下运行，因为语言帮我们解决了平台差异性问题，实现了


跨平台


！！而原生线程库的接口都是不可跨平台的，暴露和使用原生线程库都是自己决定的！

全局变量的安全性

现在我们写一个抢票的代码，抢票逻辑没有任何问题。但如果多个线程并发的执行就会出现bug： 

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

int ticket = 10000;
void *getTicket(void *args)
{
    string username = static_cast<const char *>(args);
    while (true)
    {
        if (ticket > 0)
        {
            usleep(1234);
            std::cout << username << "正在抢票:" << ticket << std::endl;
            --ticket;
        }
        else{
            break;
        }
    }
}

int main()
{
    std::unique_ptr<Thread> thread1(new Thread(getTicket, (void *)"user1", 1));
    std::unique_ptr<Thread> thread2(new Thread(getTicket, (void *)"user2", 2));
    std::unique_ptr<Thread> thread3(new Thread(getTicket, (void *)"user3", 3));
    std::unique_ptr<Thread> thread4(new Thread(getTicket, (void *)"user4", 4));

    thread1->start();
    thread2->start();
    thread3->start();
    thread4->start();

    thread1->join();
    thread2->join();
    thread3->join();
    thread4->join();
    return 0;
}

运行结果：

这时我们发现票数竟然变成了负数，原因就是当我们进行usleep操作时线程被不停的切换。例如线程a刚进入判断语句相对票数进行减减时，线程a被切换，保存在寄存器的上下文也相应地被切走。这时线程b又来了，它和线程a就一起进入了判断语句对票数进行删减操作。当b进行了20次循环操作（假设）票数减了20次，但这时线程a又被切换回来时，cpu先读取线程a中的上下文，在进行减减操作，最后再将结果写回到内存中。这样线程b再回来的时候结果就变得翻天覆地！！

发生以上问题的原因主要是++、–操作不是

原子性

的，在汇编语句上至少是三条语句：

在这里我先补充一些概念：



临界资源


：多个执行流进行安全访问的

共享资源

。



临界区


：多个执行流中，

访问临界资源的代码

。–往往是代码的很小一部分



互斥


：让多个执行流

串行

访问共享资源。



原子性


：对一个资源进行访问时，要么不做，要么就

一次性

做完。换句话来说执行的语句用

一条汇编

就能完成。

解决以上问题的手段：


加锁!!!!!

锁的常用接口：

锁的初始化：

当你定义一个锁时，如果是全局锁就可以用以下方式定义：‘

初始化以后就


不需要


对锁进行以下接口的调用：

但如果是一个


局部


的锁，就需要对锁进行以上的初始化和销毁的操作。下面定义的一个全局锁：

lock和unlock之前的代码区域就是临界区，临界区中访问的ticket就是临界资源，访问它们的方式都是


安全


的！!

现在我们使用一个局部的锁（全局的锁太简单）： 

class ThreadData
{
public:
    ThreadData(const string&threadname,pthread_mutex_t* pmutex =nullptr)
    :_threadname(threadname)
    ,_pmutex(pmutex)
    {

    }

    ~ThreadData(){}

public:
    string _threadname;
    pthread_mutex_t* _pmutex;

};

int ticket = 10000;
void *getTicket(void *args)
{
    ThreadData* td =static_cast<ThreadData*>(args);
    while (true)
    {
        pthread_mutex_lock(td->_pmutex);
        if (ticket > 0)
        {
            usleep(1234);
            std::cout <<td->_threadname << "正在抢票:" << ticket << std::endl;
            --ticket;
            pthread_mutex_unlock(td->_pmutex);

        }
        else{
            pthread_mutex_unlock(td->_pmutex);
            break;
        }
        
    }
    return nullptr;
}

int main()
{
    #define NUM 4
    pthread_mutex_t lock;
    pthread_mutex_init(&lock,nullptr);
    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,getTicket,td);
    }

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

 

    return 0;
}

当我们用了全局所以后发现几个现象：

1.抢票的速度变慢了!!!

原因：

就是加锁和解锁的过程是多个线程


串行执行的。

2.抢票的时候基本上都是一个线程抢了好多票，其他线程没有机会抢票。

原因

：

锁只是规定互斥访问，锁是多个执行流竞争的结果

。因为我们抢票的逻辑还不完整导致一个线程释放锁以后，这个线程再次进入循环申请锁。抢完票以后不应该立即再次进入循环，而是出现抢票结果的响应，但我们没有写，简单的用usleep（最后一行）代替一下：

现在我们来谈一谈对


锁的认识


：

1.锁是用来保护共享资源时其变得安全，但多个执行流申请锁致使锁也是个

共享资源

。因此申请锁和释放锁也是原子性的。

2.使用锁来保护共享资源实际上是一个执行流串行运行的结果。因此为了提高效率和速度，用锁保护的代码区域的

粒度越小越好

。

3.如果一个线程申请锁成功，即使线程被切换，它是抱着锁被切换走的!!因此当另一个线程来申请锁的时候就必须

挂起等待

。我们所学的锁也称为挂起等待锁。

4.谁持有锁谁就进入

临界区

!!!!!

锁的原子性实现原理：

在理解原理之前我们必须要有两个共识：

1.cpu只有一套寄存器被所有执行流共享。

2.cpu内寄存器的内容是每个执行流私有的，是执行流的上下文。

现在我为大家展示底层原理的代码实现：

为了保证申请锁和释放锁的原子性，大多数体系结构都提供了swap或exchange指令，它们的作用就是将寄存器里的数据和内存里的数据进行交换，并且是一步到位。

保证申请锁为原子性的方式如下：

首先1代表有锁，0代表没有锁，先将0置于一个线程的寄存器中，使寄存器中的数值成为线程a的上下文：

然后使用exchange指令将寄存器中的0和内存中的1进行交换，这样线程a就持有了锁：

由于交换数值在汇编上只有一条指令，因此保证了申请锁的原子性，那么锁被申请到了，线程a能被随意的切走吗？？答案是：当然可以！！！！因为线程a被切走时，它的上下文也随之被切走，因此当别的进程来申请锁时就申请不到内存中的锁了（内存中数值为0表示没有锁），因此被挂起等待。

如果这是线程a又被切回来，它会带着它的1（它自己的上下文）回来。这时就保证了只有一个持有锁的进程能够访问临界资源！！！释放锁的原理和上面差不多这里就不多说了。这时有人会问：假如我让一个几个线程必须持有锁才能访问资源，让一个线程不需要锁进行访问，那不就不能保证只有一个线程访问了吗？？ —————这里必须强调一下，加锁使程序员的工作，要访问就必须让所有线程持有锁访问，如果搞特殊的话这是你程序员自己代码上的失误喔！！！

锁的封装设计：（RAII）

首先我们来介绍一下什么是RAII：

以下是代码的实现： 

class Mutex
{
public:
    Mutex(pthread_mutex_t* pmutex =nullptr)
    :_pmutex(pmutex)
    {

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

    }

    void unlock()
    {
        if(_pmutex) pthread_mutex_unlock(_pmutex);

    }

    ~Mutex()
    {

    }

    pthread_mutex_t* _pmutex;
};


class Guard_Mutex
{
public:
    Guard_Mutex(pthread_mutex_t* pmutex):_mutex(pmutex)
    {
        _mutex.lock();   //构造函数中进行加锁

    }

    ~Guard_Mutex()
    {
        _mutex.unlock(); //析构函数中进行解锁
    }

private:
Mutex _mutex;

};

可重入和线程安全：

重入的概念：同一个函数被不同的执行流调用。一个执行流还没有调用完，其他执行流就再次进入这个函数。

可重入的概念：一个函数在重入的前提结果不会出现任何的问题，则称为可重入函数。

线程安全：多个线程并发同一段代码时，不会出现不同的结果。常见对全局变量或者静态变量进行操作，并且没有锁保护的情况下，会出现该问题。


常见可重入的情况

前面讲了这么多相信大家听的云里雾里的，总结一句话就是：可重入是形容函数的，而线程安全表现的是整个程序运行的结果正不正确（例如有没有对全局变量的数据做保护、有没有对函数里的共享资源上锁等等）。线程安全可能调用函数，也可能不调用。因此可重入函数一定是线程安全的，而线程安全不一定是可重入的。



常见锁概念


死锁的概念：

多个线程在不释放自己锁资源的情况下，不断的请求对方的锁资源而导致永久等待的状态。

死锁产生的

四个必要条件

：

1.互斥：这是锁的特性，每个资源每次只能被一个执行流使用。

2.请求与保持条件：对自己已经获得的资源不释放，并且不断请求对方的资源。

3.不剥夺：不强行获取对方的资源。

4.环路等待：若干执行流之间形成头尾相连的循环等待资源的关系。

破坏死锁的方法：

为了解决死锁问题，我们至少需要破坏死锁的必要条件中的一个。因为互斥是锁的基本特性，如果没有所那还谈什么死锁呢，所以互斥条件我们是没有办法解决的。因此我们根据后三条来解决：


不请求与保持

：如果一个执行流申请锁失败时，可以先立即释放自己拥有的锁资源。


剥夺

：提高某些执行流的优先级，我们当前执行流需要锁却申请不到，直接强行将锁给它。


破坏环路等待

：如果有两把锁A、B，两个执行流依次以A、B的顺序申请和释放锁，而不是一个先申请A后申请B，一个先申请B再申请A。

到这里线程下篇就结束了，接下来的内容我会基于我们所学的知识学习一些高效的模型以及线程池等相关内容，大家耐心等待！


版权声明：本文为m0_69005269原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。