Linux一学就会——线程互斥

Linux线程的互斥

进程线程间的互斥相关背景概念

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

互斥量mutex

在这里插入图片描述

大部分情况，线程使用的数据都是局部变量，变量的地址空间在线程栈空间内，这种情况，变量归属单个线程，其他线程无法获得这种变量。
但有时候，很多变量都需要在线程间共享，这样的变量称为共享变量（全局变量、静态变量等），可以通过数据的共享，完成线程之间的交互。（放在已初始化数据段内）
多个线程并发的操作共享变量，会带来一些问题。

测试函数的书写

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

int tickets=10000;

void* threadrout(void* arg)
{
    char* tname=(char*)arg;
    while(1)
    {
        if(tickets>0)
        {
            usleep(1000);
            cout<<tname<<" : 抢到一张，还剩 : "<<--tickets<<endl;
        }
        else
        {
            break;
        }
    }
}

int main()
{
    pthread_t t1,t2,t3,t4;
    pthread_create(&t1,NULL,threadrout,(void*)"t1");
    pthread_create(&t2,NULL,threadrout,(void*)"t2");
    pthread_create(&t3,NULL,threadrout,(void*)"t3");
    pthread_create(&t4,NULL,threadrout,(void*)"t4");

    pthread_join(t1,NULL);
    pthread_join(t2,NULL);
    pthread_join(t3,NULL);
    pthread_join(t4,NULL);

    return 0;
}

makefile文件的书写

testThread:testThread.cc
	g++ -o $@ $^ -std=c++11 -lpthread

.PHONY clean:
clean:
	rm -f testThread

在这里插入图片描述
居然减到负数了呢！这要是用在生活当中，一家电影院多卖了三个人的票，总不能让这三个人集体站票吧？
如果你做过单片机的项目也会出现这种情况，但单片机用消抖来消除按键抖动的，可是一个程序一定需要效率，不可能消抖呀，所以要用别的方法。

为什么可能无法获得争取结果？

if 语句判断条件为真以后，代码可以并发的切换到其他线程
usleep这个模拟漫长业务的过程，在这个漫长的业务过程中，可能有很多个线程会进入该代码段
–ticket操作本身就不是一个原子操作（不是一条汇编指令完成的）

减减操作并不是原子操作，而是对应三条汇编指令：
load：将共享变量ticket从内存加载到寄存器中
update: 更新寄存器里面的值，执行-1操作
store：将新值，从寄存器写回共享变量ticket的内存地址

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

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

要做到这三点，本质上就是需要一把锁。Linux上提供的这把锁叫互斥量。
在这里插入图片描述
互斥量的接口
初始化互斥量
初始化互斥量有两种方法：

方法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

采用动态加锁代码

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

int tickets=10000;
pthread_mutex_t mx;

void* threadrout(void* arg)
{
    char* tname=(char*)arg;
    while(1)
    {
        pthread_mutex_lock(&mx);
        //while中包裹的都是临界区
        if(tickets>0)
        {
            usleep(1000);
            cout<<tname<<" : 抢到一张，还剩 : "<<--tickets<<endl;
            pthread_mutex_unlock(&mx);
        }
        else
        {
            pthread_mutex_unlock(&mx);
            break;

        }
    }
}

int main()
{
    pthread_mutex_init(&mx,NULL);
    pthread_t t1,t2,t3,t4;
    pthread_create(&t1,NULL,threadrout,(void*)"t1");
    pthread_create(&t2,NULL,threadrout,(void*)"t2");
    pthread_create(&t3,NULL,threadrout,(void*)"t3");
    pthread_create(&t4,NULL,threadrout,(void*)"t4");

    pthread_join(t1,NULL);
    pthread_join(t2,NULL);
    pthread_join(t3,NULL);
    pthread_join(t4,NULL);

    pthread_mutex_destroy(&mx);

    return 0;
}

在这里插入图片描述
速度一下就慢了好多。

但是有一个问题，就是一个线程会枪好久，一直不轮转。
如图：
在这里插入图片描述
稍微修改一下：

void* threadrout(void* arg)
{
    char* tname=(char*)arg;
    while(1)
    {
        pthread_mutex_lock(&mx);
        //while中包裹的都是临界区
        if(tickets>0)
        {
            usleep(1000);
            cout<<tname<<" : 抢到一张，还剩 : "<<--tickets<<endl;
            pthread_mutex_unlock(&mx);
        }
        else
        {
            pthread_mutex_unlock(&mx);
            break;

        }
        usleep(1000);//增加一个休息轮转的时间
    }
}

在这里插入图片描述

但是速度就又慢了一些。

互斥量实现原理探究

经过上面的例子，大家已经意识到单纯的i++或者++i都不是原子的，有可能会有数据一致性问题

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

在这里插入图片描述

可重入VS线程安全

概念

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