Linux多线程——互斥锁

本质Gitee仓库:互斥锁、锁封装

1. 线程互斥

一个共享资源在被多个线程并发访问的时候，可能会出现一个线程正在访问，而另一个线程又来读或者写，从而出现访问的数据不一致问题。

int tickets = 1000; //模拟多线程抢票
#define NUM 5

class threadDate
{
public:
    threadDate(int num)
    {
        _name = "thread " + to_string(num);
    }
public:
    string _name;
};
void* getTicket(void *args)
{
    threadDate *td = static_cast<threadDate*>(args);
    const char *name = td->_name.c_str();
    while(true)
    {
        if(tickets > 0)
        {
            usleep(1000); //假设抢到票之后执行的操作所需时间
            printf("who: %s, get a ticket: %d\n",name, tickets);
            tickets--;
        }
        else
            break;
    }
    return nullptr;
}

int main()
{
    vector<pthread_t> tids;
    vector<threadDate*> thread_datas;
    for(int i = 0; i < NUM; i++)
    {
        pthread_t tid;
        threadDate *td = new threadDate(i);
        thread_datas.push_back(td);
        pthread_create(&tid, nullptr, getTicket, thread_datas[i]);
        tids.push_back(tid);
    }

    for(auto e : tids)
    {
        pthread_join(e, nullptr);
    }

    for(auto e : thread_datas)  delete e;
    return 0;
}

运行发现，票抢到了0、-1、-2张，这显然是不符合预期的

我们这里抢票，本质就是对tickets进行tickers--操作，要对数据做计算，是要到CPU当中进行计算的。

1. 将tickets读入到CPU寄存器当中；
2. 在CPU内部进行ticket--操作；
3. 将计算结果写回内存

所以这个ticket--是对应这三步操作的，而这三步，每一步都会对应一条汇编操作。

当一个线程读取这个票的数据时，它是随时可能会被切换走的，当它要被切换时，会保存它自己线程对应的上下文数；

线程在执行的时候，将共享数据放到自己的上下文本质上就是把数据内容变成了自己的上下文，意思就是说以拷贝的方式，给自己单独拿了一份

然后新切换的线程，它第一步也是先将数据读取到CPU当中，然后它顺利完成自己的操作，没有被切换走，假设它完成了900轮抢票操作再被切换，此时票还剩100张

原先被切换的线程再回来的时候，首先就是恢复自己的上下文数据，它还以为有1000张票，自己拿一张走，然后tickets--，然后再写好内存，此时，数据又变成了999。这就出现了数据不一致问题。

我们上面代码的操作，是先对tickets进行判断，线程判断进去之后，再被切换，当票被抢完之后，它并不知道，所以票就会抢到负数（读数据、修改数据、写回内存，每次都会重新读取tickets的数据）。

要解决这个问题，我们须要保证对任何共享数据进行访问的时候，只有一个执行流在进行访问。

2. 互斥锁

2.1 锁的初始化与释放

我们可以采取加锁的方式，来保证原子性。

#include 
int pthread_mutex_destroy(pthread_mutex_t *mutex);
int pthread_mutex_init(pthread_mutex_t *restrict mutex,const pthread_mutexattr_t *restrict attr);
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

• pthread_mutex_t是库给我们提供的一种数据类型
• 初识化这把锁有两种方案：
  1. pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER定义成全局的，不需要我们再销毁
  2. pthread_mutex_init(pthread_mutex_t *restrict mutex,const pthread_mutexattr_t *restrict attr)，普通初始化，使用完之后，再用pthread_mutex_destroy(pthread_mutex_t *mutex)进行释放即可。

2.2 加锁与解锁

#include 
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);

我们把tickets这个共享的全局变量，叫做临界资源，在整个多线程中，并不是所有代码都在访问临界资源，只有一小块代码会访问到，这一小块的代码叫做临界区，这就是要进行保护的部分，我们的目的就是让加锁的区域串行访问。

加锁的本质：时间换安全

加锁原则：保证临界区的代码越少越好，因为加锁的区域是串行访问，如果加锁区域很大，那么线程的并发度就降低了

int tickets = 5000; //模拟多线程抢票
#define NUM 5

class threadDate
{
public:
    threadDate(int num, pthread_mutex_t *mutex)
    {
        _name = "thread " + to_string(num);
        _lock = mutex;
    }
public:
    string _name;
    pthread_mutex_t *_lock;
};
void* getTicket(void *args)
{
    threadDate *td = static_cast<threadDate*>(args);
    const char *name = td->_name.c_str();
    while(true)
    {
        pthread_mutex_lock(td->_lock);
        if(tickets > 0)
        {
            usleep(1000);
            printf("who: %s, get a ticket: %d\n",name, tickets);
            tickets--;
            pthread_mutex_unlock(td->_lock);
        }
        else
        {
            //防止进来之后发现没票直接break导致锁没有被释放  
            pthread_mutex_unlock(td->_lock);
            break;
        }
        //防止一个线程竞争力太强，一直持有锁
        //同时模拟多线程抢到票之后执行后续的操作
        usleep(10);
    }
    return nullptr;
}

int main()
{
    pthread_mutex_t lock;	//定义锁
    pthread_mutex_init(&lock, nullptr);	//初始化
    vector<pthread_t> tids;
    vector<threadDate*> thread_datas;
    for(int i = 0; i < NUM; i++)
    {
        pthread_t tid;
        threadDate *td = new threadDate(i, &lock);
        thread_datas.push_back(td);
        pthread_create(&tid, nullptr, getTicket, thread_datas[i]);
        tids.push_back(tid);
    }

    for(auto e : tids)
    {
        pthread_join(e, nullptr);
    }

    for(auto e : thread_datas)  delete e;
    pthread_mutex_destroy(&lock);	//释放锁
    return 0;
}

这里也可以采用全局加锁的方式

pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
//....
void *thread(void *args)
{
    //临界区
    pthread_mutex_lock(&lock);
    //....
    pthread_mutex_unlock(&lock);
    //....
}

Tips：

• 锁本身就是原子的，只有持有锁和释放锁；

  在临界区，线程也是可以被切换，但由于锁是原子的，就算被切换了，其他线程也进不来，所以当前线程访问临界区的过程，对于其他线程就是原子的

• 我们上面的代码是互斥环境，如果一个线程频繁的持有锁，这就会使其他线程长时间得不到资源从而导致饥饿问题；

• 如果一个线程释放了资源，外面的线程就会被全部唤醒，然后去争夺一个锁，这就会导致操作系统进行了很大无效的操作，所以我们可以规定：

  1. “外面”的线程必须“排队”
  2. “出来”的线程不能立马申请锁，必须到队尾重新“排队”

  这样就让线程获取锁有了一定的顺序性，这个叫做同步

3. 锁的原理

为了实现互斥锁操作,大多数体系结构都提供了swap或exchange指令,该指令的作用是把寄存器和内存单 元的数据相交换,由于只有一条指令,保证了原子性。

lock:
	movb $0, %al
    xchgb %al, mutex
    if(al寄存器内容 > 0){
        return 0;	//	申请锁成功
    }
	else{
        等待挂起;
    }
	goto:lock;
unlock:
	movb $1, mutex
    唤醒等待Mutex的线程;
    return 0;

这个锁也是共享资源，在申请的时候，也是会被切换：

这里交换的本质就是将内存的时间交换到CPU寄存器当中，这个内存的数据是线程共享的，意思就是谁将内存的1交换到了自己的cpu寄存器中，谁就能申请到锁。

解锁操作就没有进行交换了，就直接将1写到内存当中了。

4. 锁的封装

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;
};

使用：

void *getTicket(void *args)
{
    threadDate *td = static_cast<threadDate *>(args);
    const char *name = td->_name.c_str();
    int cnt = 0;
    while (true)
    {
        {
            // 无需再进行加锁解锁
            // 创建临时对象调用构造——>加锁
            //   出了临界区调用析构——>解锁
            //   RAII机制   
            lockGuard lockguard(td->_lock);
            //pthread_mutex_lock(td->_lock);
            if (tickets > 0)
            {
                usleep(1000);
                printf("who: %s, get a ticket: %d\n", name, tickets);
                cnt++;
                tickets--;
                //pthread_mutex_unlock(td->_lock);
            }
            else
            {
                printf("%s quit... get tickets: %d\n", name, cnt);
                // 防止进来之后发现没票直接break导致锁没有被释放
                //pthread_mutex_unlock(td->_lock);
                break;
            }
        }

        // 防止一个线程竞争力太强，一直持有锁
        // 同时模拟多线程抢到票之后执行后续的操作
        usleep(10);
    }
    // delete td;
    return nullptr;
}

5. 线程安全与可重入函数

这里就2点：

1. 可重入函数一定是线程安全的
2. 线程安全不一定是可重入的

线程安全描述的是线程并发的问题，可重入函数描述的是函数特点的问题。