Linux线程互斥

Linux线程互斥

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

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

互斥量mutex

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

例如：

//操作共享变量会有问题的售票系统代码
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
		
int ticket = 100;
void *route(void *arg)
{
    char *id = (char *)arg;
    while (1)
    {
        if (ticket > 0)
        {
            usleep(1000);
            printf("%s sells ticket:%d\n", id, ticket);
            ticket--;
        }
        else
        {
            break;
        }
    }
}
int main(void)
{
    pthread_t t1, t2, t3, t4;
    pthread_create(&t1, NULL, route, (void *)"thread 1");
    pthread_create(&t2, NULL, route, (void *)"thread 2");
    pthread_create(&t3, NULL, route, (void *)"thread 3");
    pthread_create(&t4, NULL, route, (void *)"thread 4");
    
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
}

该程序运行可能会产生如下结果:

造成此中情况的原因：

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

要想解决多线程的数据不一致问题，就需要做到以下几点：

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

其实做到上面三点只需要一把互斥锁( mutex )，将锁看作一个通行证，持有锁的线程才能进入临界区中执行代码，其他线程不持有锁，无法进入该临界区。

加锁本质就是让共享资源临界资源化，多个线程串行访问共享资源，从而保护共享资源的安全。

互斥锁本质上就是一个类（class pthread_mutex_t），可以构造对象pthread_mutex_t mutx，mutx就是互斥锁对象。

加锁可以让共享资源临界资源化，从而保护共享资源的安全，让多个线程串行访问共享资源。

mutex 接口

同创建线程一样，锁也需要创建，POSIX提供了锁的变量类型，如上面代码所示，其中mutext是互斥量

使用互斥量需要包含头文件：

#include<pthread.h>

初始化互斥量

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

• 方法1，静态分配

  pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER
  //初始化全局锁
  

• 方法2，动态分配

  pthread_mutex_init

  int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict 
  attr); 
  //初始化局部锁
  
  //例:
  int main()
  {
      pthread_mutex_t mutex;
  	pthread_mutex_init(&mutex,nullptr);
  }
  

  参数：

  • mutex：要初始化的互斥量
  • attr ：NULL

销毁互斥量

销毁互斥量需要注意：

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

pthread_mutex_destroy

int pthread_mutex_destroy(pthread_mutex_t *mutex)
//例:
//pthread_mutex_destroy(&mutex);

加锁和解锁

pthread_mutex_lock

int pthread_mutex_lock(pthread_mutex_t *mutex);
//例:
//pthread_mutex_lock(&mutex);

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

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

pthread_mutex_unlock

int pthread_mutex_unlock(pthread_mutex_t *mutex);
//例:
//pthread_mutex_unlock(&mutex);

加锁解锁的原理

c/c++中加加和减减的操作并不是原子的，所以会导致多线程数据不一致的问题。

而为了能让加锁过程是原子的，在大多数体系结构了，都提供了swap或者xchange汇编指令，通过一条汇编指令来保证加锁的原子性。

pthread_mutex_lock(mutex);
//代码片段(原子的)
pthread_mutex_unlock(mutex);

在加锁与解锁间，就能保证中间的区域为临界区，里面的操作都是原子的

使用示例

再次模拟抢票系统

#include <iostream>
#include <unistd.h>
#include <vector>

#include "Thread.hpp"

using std::vector;

int ticket = 1000;                                 // 多线程可以直接访问
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; // 初始化全局锁,也可以是局部的

void GetTicket(pthread_mutex_t* mutex)
{
    while (1)
    {
        pthread_mutex_lock(mutex); // 加锁
        // 在同一时刻，只允许一个线程申请锁成功! 多个线程申请锁失败，失败的线程在mutex上阻塞等待
        if (ticket > 0)
        {                 // 在加锁的时候,线程可能被切换,但是线程在切换时带走了[钥匙]，别的进程也无法进行修改
            usleep(1000); // 1000微秒
            cout << " get a ticket: " << ticket-- << endl;
            pthread_mutex_unlock(mutex); // 解锁
        }
        else
        {
            pthread_mutex_unlock(mutex); // 解锁
            break;
        }
    }

    // 模拟抢票，实际情况还有很多后续代码
}

// 应用方的文件
string GetThreadName()
{
    static int number = 1;
    char name[64];
    snprintf(name, sizeof name, "Thread-%d", number++);
    return name;
}

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

int main()
{
    pthread_mutex_t mutex;             //创建局部锁
    pthread_mutex_init(&mutex,nullptr); //初始化局部锁

    string name1 = GetThreadName();
    Thread<pthread_mutex_t*> t1(GetTicket, name1, &mutex);

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

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

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

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

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

    pthread_mutex_destroy(&mutex);
}

#pragma once

#include<pthread.h>

class Mutex
{
    pthread_mutex_t *_mutex;
public:
    Mutex(pthread_mutex_t *__mutex):_mutex(__mutex)
    {

    }
    ~Mutex()
    {

    }

    void Lock()
    {
        pthread_mutex_lock(_mutex);
    }

    void Unlock()
    {
        pthread_mutex_unlock(_mutex);
    }

};

class LockGuard
{
    Mutex _Mutex;
public:
    LockGuard(pthread_mutex_t* __mutex)
    :_Mutex(__mutex)
    {
        _Mutex.Lock();
    }

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