Linux（十）线程安全

曾几何时`

已于 2023-02-13 11:41:29 修改

阅读量606

点赞数 1

分类专栏： LInux 文章标签： java 开发语言

于 2023-02-10 16:47:30 首次发布

本文链接：https://blog.csdn.net/weixin_66151870/article/details/128915462

版权

LInux 专栏收录该内容

22 篇文章 1 订阅

订阅专栏

一、概念

概念：在多线程程序中，如果涉及到了对共享资源的操作，则有可能会导致数据二义性，而线程安全就指的是，就算对共享资源进行操作也不会导致数据二义

实现：如何实现多线程中对共享资源的操作不会出问题

互斥：通过同一时间对资源访问的唯一性，保证访问安全

互斥的实现：互斥锁（读写锁、自旋锁...）

同步：通过条件控制，让多执行对资源的获取更加合理

同步实现：条件变量、信号量

二、互斥锁实现互斥

实现对共享资源的唯一访问

1）互斥锁实现互斥的原理

        本质：就是一个1/0计数器，通过0/1标记资源的访问状态（0-不可访问、1-可访问）

                   在访问资源之前进行加锁（通过状态判断是否可访问，不可访问则阻塞）

                   在访问资源之后进行解锁（将资源状态置为可访问状态，唤醒其他阻塞的线程）

        也有另一种理解：访问资源之前加锁（获取锁资源-获取不到就阻塞）

                                     访问完毕解锁（归还锁资源）

        多个线程想要实现互斥，就必须访问同一个锁才可以，也就意味着锁也是一个共享资源

互斥锁的操作本身必须是安全的：互斥锁本身计数器的操作时原子操作

2）互斥锁如何实现自身操作安全的原理

我们知道内存与cpu之间的数据传输：当进行加锁操作时，先将锁中的1置入cpu（先将变量数据从内存加载到cpu）然后才能从cpu中对数据进行处理（转化为0）然后在从cpu中将数据加载到内存指定位置（完成将1替换为0）

然而这样一种操作就会产生问题，如果1从内存加载到cpu还没有将处理后的0加载回内存时，这时切换其他线程运行访问到的锁资源仍然为1，就会继续进行加锁，这无疑是致命的。

所以对于锁资源本身来说，计数器的操作必须是原子性的才可以。

有个指令类似于exchange，功能是交换指定寄存器与内存中的数据

1、先将指定寄存器中的值修改为0,

2、将寄存器与内存中的数据进行互换

3、判断是否符合获取锁的条件或者说判断是否能够加锁

这样使用exchange指令就可以实现计数器操作为原子操作。

3）接口

互斥锁类型变量 pthread_mutex_t

初始化互斥锁

int pthread_mutex_init（pthread_mutex_t *mutex, pthread_mutexattr_t *attr）

mutex：互斥锁变量的地址 attr：互斥锁变量属性（通常置NULL）

访问资源前加锁

int pthread_mutex_lock（pthread_mutex_t *mutex）阻塞加锁（老实人）

int pthread_mutex_trylock（pthread_mutex_t *mutex）非阻塞加锁（海王）

访问资源后解锁

int pthread_mutex_unlock（pthread_mutex_t *mutex）

释放销毁互斥锁

int pthread_mutex_destroy（pthread_mutex_t *mutex）

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER （这种初始化不需要销毁）

4）代码模拟

当不使用互斥锁线程之间对同一变量的访问情况如何？

#include<stdio.h>
#include<pthread.h>
#include<unistd.h>

int ticket = 100;
void *Scalper(void *arg)
{
    while(1)
    {
        if(ticket > 0)
        {
          usleep(10);
          printf("%p：我抢到了第 %d 号票\n",pthread_self(), ticket);
          ticket--;
        }
        else{
          printf("%p：票完了，我的工作结束了\n", pthread_self());
          break;
        }
    }
    return NULL;
}
int main()
{
    pthread_t tid[4];
    for(int i = 0; i < 4; i++)
    {
        int ret = pthread_create(&tid[i], NULL, Scalper, NULL);
        if(ret != 0){
          perror("create error");
          return -1;
        }
    }
    for(int i = 0; i < 4; i++)
    {
        pthread_join(tid[i], NULL);
    }
    return 0;
}

发现出现了很多意外情况，重复、负数票号，

为什么呢？就是因为每个线程之间访问同一变量，一个线程还正对变量进行操作的时候另一个线程也进行操作，于是就发生了同一变量的多次出现。

使用互斥锁保护临界区

#include<stdio.h>
#include<pthread.h>
#include<unistd.h>

int ticket = 100;
void *Scalper(void *arg)
{
    while(1)
    {
        pthread_mutex_lock(arg);    // 访问之前加锁
        if(ticket > 0)
        {
          usleep(10);
          printf("%p：我抢到了第 %d 号票\n",pthread_self(), ticket);
          ticket--;
          pthread_mutex_unlock(arg);    // 在所有有可能退出的地方解锁
        }
        else{
          printf("%p：票完了，我的工作结束了\n", pthread_self());
          pthread_mutex_unlock(arg);    // 在所有有可能退出的地方解锁
          break;
        }
        usleep(1);
    }
    return NULL;
}
int main()
{
    pthread_mutex_t mutex;    // 定义锁变量 mutex
    pthread_mutex_init(&mutex, NULL);    // 初始化锁资源
    pthread_t tid[4];
    for(int i = 0; i < 4; i++)
    {
        int ret = pthread_create(&tid[i], NULL, Scalper, &mutex); 
                                    // 注意锁资源通过线程创建第四个参数传入入口函数内
        if(ret != 0){
          perror("create error");
          return -1;
        }
    }
    for(int i = 0; i < 4; i++)
    {
        pthread_join(tid[i], NULL);
    }
    return 0;
}

5）死锁

死锁是一种状态，是一种因为资源争抢不当导致程序流程卡死无法继续向下推进的状态。

多个线程对锁资源的争抢使用不当导致程序流程卡死，无法继续向下推进的状态

1、加锁之后没有释放就退出，导致其他线程获取不到锁资源卡死

2、多锁使用时，加锁顺序不当，线程1加锁顺序为AB，线程2加锁顺序为BA

发生死锁的必要条件

① 互斥条件 同一时间一把锁只能被一个线程所获取到

② 不可剥夺条件 一个线程加的锁，只能自己释放，其他线程无法释放

③ 请求与保持 一个线程请求了A锁之后请求B锁，如果请求不到就不会释放A锁

④ 环路等待 线程1加了A锁后请求B锁，线程2加了B锁后请求A锁

死锁的预防：破坏死锁产生的必要条件

① 和 ② 无法修改

写代码时要注意：

1、线程之间的加解锁顺序尽量一致 -- 尽可能预防环路等待

2、采用非阻塞加锁，如果加不上锁，则把已经加上的锁释放 -- 破坏请求与保持

（请求不到新的，则释放已有的）

避免：银行家算法、死锁检测算法……

银行家算法http://t.csdn.cn/1YxZj

三、条件变量实现同步

1）概念

同步：通过条件控制，保证资源访问的合理性

条件变量：主要是一个pcb等待队列，以及唤醒和阻塞线程的接口

原理：

线程1 获取资源时进行判断，如果线程不符合资源获取条件，则调用阻塞接口进行阻塞

线程2 促使资源获取条件满足之后（生产资源），通过唤醒接口唤醒阻塞的线程

条件变量需要搭配互斥锁来使用

举例：

顾客与厨师（消费者与生产者）

顾客来到柜台，看到柜台有饭则吃饭，否则阻塞

厨师来到柜台，看到柜台上没有饭则做饭，否则阻塞

顾客：

0、加锁（关门）

1、访问柜台有没有饭

有饭则吃饭，没有饭就阻塞

（这里阻塞时需要进行解锁，否则厨师就无法访问柜台，也就无法做饭，产生死锁）

阻塞则需先解锁，再阻塞，被唤醒之后再加锁

2、吃饭

3、吃完了，再来一碗唤醒厨师

4、解锁

厨师：

0、加锁

1、访问柜台有没有饭

没饭则做饭，有饭则阻塞

（这里是有饭就需要解锁，让顾客能够吃饭，否则会死锁）

阻塞需先解锁，再阻塞，被唤醒后加锁

2、做饭

3、做好了，唤醒顾客

4、解锁

2）接口

定义条件变量：

pthread_cond_t 条件变量的变量类型

初始化条件变量：

pthread_cond_t cond_init (pthread_cond_t *cond, pthread_condattr_t *attr);

阻塞接口：条件变量是搭配互斥锁一起使用的，就体现在阻塞这一步

int pthread_cond_wait (pthread_cond_t *cond, pthread_mutex_t *mutex) -- 阻塞接口

int pthread_cond_timewait(pthread_cond_t *cond, pthread_mutex_t *mutex,

struct timespec *t ) -- 有时长限制的阻塞

唤醒接口：

int pthread_cond_signal（pthread_cond_t *cond）唤醒至少一个阻塞队列中的线程

int pthread_cond_broadcast（pthread_cond_t *cond）唤醒等待队列中所有的线程

销毁接口：

int pthread_cond_destroy（pthread_cond_t *cond）

3）模拟实现

#include<stdio.h>
#include<pthread.h>

int counter = 0;    // 定义柜台状态 0——没饭   1——有饭 
pthread_mutex_t mutex;    // 初始化锁
pthread_cond_t cond;    // 初始化条件变量

void* customer(void *arg)
{
    while(1)
    {
      pthread_mutex_lock(&mutex);    // 先加锁
      if(counter==0){
        pthread_cond_wait(&cond, &mutex);    // 没饭则解锁 并阻塞，等待唤醒，唤醒后加锁
      }
      printf("真好吃，再来一碗\n");
      counter = 0;
      pthread_cond_signal(&cond);    // 吃完了唤醒厨师做饭
      pthread_mutex_unlock(&mutex);    // 解锁
    }
}

void* cook(void *arg)
{
    while(1)
    {
      pthread_mutex_lock(&mutex);    // 加锁
      if(counter == 1){
        pthread_cond_wait(&cond, &mutex);    // 有饭则 解锁并阻塞，等待唤醒，唤醒后加锁
      }
      printf("你的饭好了\n");
      counter = 1;
      pthread_cond_signal(&cond);    // 饭做好了唤醒顾客吃饭
      pthread_mutex_unlock(&mutex);    // 解锁
    }
}



int main()
{
    pthread_mutex_init(&mutex, NULL);    // 初始化定义mutex 和 cond
    pthread_cond_init(&cond, NULL);
    pthread_t cook_tid;    // 初始化定义线程ID（顾客和厨师）
    pthread_t cus_tid;
    int ret;
    ret = pthread_create(&cook_tid, NULL, cook, NULL);    // 分别创建对应线程
    if(ret != 0){
      perror("create error");
      return -1;
    }
    ret = pthread_create(&cus_tid, NULL, customer, NULL);
    if(ret != 0){
      perror("create error");
      return -1;
    }

    pthread_join(cook_tid, NULL);    // 执行线程等待
    pthread_join(cus_tid, NULL);
    pthread_mutex_destroy(&mutex);    // 执行mutex与cond的销毁
    pthread_cond_destroy(&cond);
}

实现四个顾客四个厨师

在同步实现的代码中，如果存在多种角色，就应该定义多个条件变量，各自处于各自的pcb等待队列中。

#include<stdio.h>
#include<pthread.h>

int counter = 0;
pthread_mutex_t mutex;
pthread_cond_t cond_cus;    // 使用不同的条件变量，防止死锁
pthread_cond_t cond_cook;
void* customer(void *arg)
{
  while(1)
  {
    pthread_mutex_lock(&mutex);
    while(counter <= 0){
      pthread_cond_wait(&cond_cus, &mutex);
    }
    printf("真好吃，再来一碗: %d\n",counter);
    counter--;
    pthread_cond_signal(&cond_cook);
    pthread_mutex_unlock(&mutex);
  }
}

void* cook(void *arg)
{
  while(1)
  {
    pthread_mutex_lock(&mutex);
    while(counter > 0){
      pthread_cond_wait(&cond_cook, &mutex);
    }
    printf("你的饭好了：%d\n", counter);
    counter++;
    pthread_cond_signal(&cond_cus);
    pthread_mutex_unlock(&mutex);
  }
}


int main()
{
  pthread_mutex_init(&mutex, NULL);
  pthread_cond_init(&cond_cus, NULL);
  pthread_cond_init(&cond_cook, NULL);
  pthread_t cook_tid[4];    // 定义四个顾客、四个厨师
  pthread_t cus_tid[4];
  int ret;
  for(int i = 0; i < 4; i++) // 创建这八个线程
  {
    ret = pthread_create(&cook_tid[i], NULL, cook, NULL);
    if(ret != 0){
      perror("create error");
      return -1;
    }
    ret = pthread_create(&cus_tid[i], NULL, customer, NULL);
    if(ret != 0){
      perror("create error");
      return -1;
    }
  }

  pthread_join(cook_tid[0], NULL);
  pthread_join(cus_tid[0], NULL);
  pthread_mutex_destroy(&mutex);
  pthread_cond_destroy(&cond_cook);
  pthread_cond_destroy(&cond_cus);
}

生产者与消费者模型

生产者与消费者模型http://t.csdn.cn/GvZlZ

四、信号量实现同步与互斥

作用：实现线程或进程间的同步与互斥

本质：就是一个计数器

操作：通过对计数器对资源进行计数，实现资源使用的同步与互斥

P操作：对计数器-1，如果小于0就表示没有资源，阻塞

V操作：对计数器+1，唤醒一个阻塞中的线程

同步实现：

初始化计数器为资源数量，在访问资源前进行P操作，访问资源后进行V操作

互斥实现：（把它当成0-1计数器的锁）

初始化计数器为1，在访问资源前进行P操作，访问资源后进行V操作

接口：POSIX标准

头文件：#include<semaphore.h>

信号量变量类型 sem_t sem

信号量初始化： int sem_init（sem_t *sem，int pshared，int val）

sem定义的信号量变量

pshared：0-线程间，！0进程间（共享内存）

val：信号量初始值

成功返回0，失败返回-1

P操作： int sem_wait（sem_t *sem）（阻塞接口）

int sem_trywait（sem_t *sem）（非阻塞接口）

int sem_timewait（sem_t *sem，const struct timespec *abs_timeout）

阻塞但有时长限制

V操作： int sem_post （sem_t *sem）

信号量销毁：int sem_destroy（sem_t *sem）

实现一个线程安全的环形队列

头文件：

#include<iostream>
#include<vector>
#include<semaphore.h>    // 信号量相关头文件
#include<pthread.h>
#include<stdio.h>

环形队列的实现

#define MAX_CAP 6
template <class T>
class RingQueue
{
    private:
        std::vector<T> _array;
        int _pread;
        int _pwrite;
        int _capacity;
        sem_t _idle_sem;    // 空闲空间信号量
        sem_t _data_sem;    // 数据空间信号量
        sem_t _lock_sem;    // 实现互斥信号量
    public:
        RingQueue(int capacity = MAX_CAP)
            : _array(capacity)
            , _capacity(capacity)
            , _pread(0)
            , _pwrite(capacity)
        {
            sem_init(&_idle_sem, 0, capacity);// 初始化
            sem_init(&_data_sem, 0, 0);
            sem_init(&_lock_sem, 0, 1);
        }
        ~RingQueue()
        {
            sem_destroy(&_idle_sem);    // 销毁
            sem_destroy(&_data_sem);
            sem_destroy(&_lock_sem);
        }
        bool Push(const T& data)
        {
            // 必须先进行P操作，再进行加锁
            sem_wait(&_idle_sem);   // 实现P操作、对空闲空间进行计数-1
            sem_wait(&_lock_sem);   // 进行加锁
            _array[_pwrite] = data;
            _pwrite = (_pwrite+1)%_capacity;
            sem_post(&_lock_sem);    // 解锁
            sem_post(&_data_sem);    // 唤醒一个读取数据的线程
        }
        bool Pop(T *data)
        {
            sem_wait(&_data_sem);   // 实现P操作、对数据空间进行计数-1
            sem_wait(&_lock_sem);   // 加锁
            *data = _array[_pread];
            _pread = (_pread+1)&_capacity;
            sem_post(&_lock_sem);    // 解锁
            sem_post(&_idle_sem);    // 唤醒一个写入数据线程
        }
};

创建不同线程实现分别实现Push、Pop

void *Push_entry(void *arg)
{
    RingQueue<int>* q = (RingQueue<int>*)arg;
    int data = 1;
    while(1)
    {
        q->Push(data);
        printf("+++++%p: Push: %d\n", pthread_self(), data++);
    }
    return NULL;
}
void *Pop_entry(void *arg)
{
    RingQueue<int>* q = (RingQueue<int>*)arg;
    while(1)
    {
        int data;
        q->Pop(&data);
        printf("-----%p: Pop: %d\n", pthread_self(), data);
    }
    return NULL;
}

#define MAX_COT 4

int main()
{
    RingQueue<int> q;
    pthread_t pth_push[MAX_COT];
    pthread_t pth_pop[MAX_COT];
    int ret = 0;
    for(int i = 0; i < MAX_COT; i++)
    {
        ret = pthread_create(&pth_push[i], NULL, Push_entry, (void*)&q);
        if(ret < 0)
        {
            perror("create error");
            return -1;
        }
        ret = pthread_create(&pth_pop[i], NULL, Pop_entry, (void*)&q);
        if(ret < 0)
        {
            perror("create error");
            return -1;
        }
    }
    for(int i = 0; i < MAX_COT; i++)
    {
        pthread_join(pth_pop[i], NULL);
        pthread_join(pth_push[i], NULL);
    }

    return 0;
}

源码

#include<iostream>
#include<vector>
#include<semaphore.h>
#include<pthread.h>
#include<stdio.h>

#define MAX_CAP 6
template <class T>
class RingQueue
{
    private:
        std::vector<T> _array;
        int _pread;
        int _pwrite;
        int _capacity;
        sem_t _idle_sem;    // 空闲空间信号量
        sem_t _data_sem;    // 数据空间信号量
        sem_t _lock_sem;    // 实现互斥信号量
    public:
        RingQueue(int capacity = MAX_CAP)
            : _array(capacity)
            , _capacity(capacity)
            , _pread(0)
            , _pwrite(capacity)
        {
            sem_init(&_idle_sem, 0, capacity);
            sem_init(&_data_sem, 0, 0);
            sem_init(&_lock_sem, 0, 1);
        }
        ~RingQueue()
        {
            sem_destroy(&_idle_sem);
            sem_destroy(&_data_sem);
            sem_destroy(&_lock_sem);
        }
        bool Push(const T& data)
        {
            // 必须先进行P操作，再进行加锁
            sem_wait(&_idle_sem);   // 实现P操作、对空闲空间进行计数-1
            sem_wait(&_lock_sem);   // 进行加锁
            _array[_pwrite] = data;
            _pwrite = (_pwrite+1)%_capacity;
            sem_post(&_lock_sem);    // 解锁
            sem_post(&_data_sem);    // 唤醒一个读取数据的线程
        }
        bool Pop(T *data)
        {
            sem_wait(&_data_sem);   // 实现P操作、对数据空间进行计数-1
            sem_wait(&_lock_sem);   // 加锁
            *data = _array[_pread];
            _pread = (_pread+1)&_capacity;
            sem_post(&_lock_sem);    // 解锁
            sem_post(&_idle_sem);    // 唤醒一个写入数据线程
        }
};

void *Push_entry(void *arg)
{
    RingQueue<int>* q = (RingQueue<int>*)arg;
    int data = 1;
    while(1)
    {
        q->Push(data);
        printf("+++++%p: Push: %d\n", pthread_self(), data++);
    }
    return NULL;
}
void *Pop_entry(void *arg)
{
    RingQueue<int>* q = (RingQueue<int>*)arg;
    while(1)
    {
        int data;
        q->Pop(&data);
        printf("-----%p: Pop: %d\n", pthread_self(), data);
    }
    return NULL;
}

#define MAX_COT 4

int main()
{
    RingQueue<int> q;
    pthread_t pth_push[MAX_COT];
    pthread_t pth_pop[MAX_COT];
    int ret = 0;
    for(int i = 0; i < MAX_COT; i++)
    {
        ret = pthread_create(&pth_push[i], NULL, Push_entry, (void*)&q);
        if(ret < 0)
        {
            perror("create error");
            return -1;
        }
        ret = pthread_create(&pth_pop[i], NULL, Pop_entry, (void*)&q);
        if(ret < 0)
        {
            perror("create error");
            return -1;
        }
    }
    for(int i = 0; i < MAX_COT; i++)
    {
        pthread_join(pth_pop[i], NULL);
        pthread_join(pth_push[i], NULL);
    }

    return 0;
}