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。

到这里线程中篇就结束了，线程下篇持续更新，希望大家多多支持！