Linux线程安全

最新推荐文章于 2023-08-21 16:52:44 发布

"派派"

最新推荐文章于 2023-08-21 16:52:44 发布

阅读量544

点赞数 2

分类专栏： Linux学习文章标签：开发语言 linux c++

本文链接：https://blog.csdn.net/m0_64397669/article/details/128031934

版权

Linux学习专栏收录该内容

16 篇文章 0 订阅

订阅专栏

一.Linux线程互斥

1.1互斥相关概念

临界资源：多线程执行流共享的资源就叫做临界资源

临界区：每个线程内部，访问临界资源的代码，就叫做临界区

互斥：任何时刻，互斥保证有且只有一个执行流进入临界区，访问临界资源，通常对临界资源起保护作用

原子性：不会被任何调度机制打断的操作，该操作只有两态，要么完成，要么未完

成

线程互斥：线程互斥指的是在多个线程间对临界资源进行争抢访问时有可能会造成数据二义，因此通过保证同一时间只有一个线程能够访问临界资源的方式实现线程对临界资源的访问安全性。

模拟实现一个抢票系统，定义一个全局变量来表示票的数量，后面主线程创建多个线程进行抢票，查看现象。

代码演示：

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

int tickets=1000;
void* getTickets(void* args)
{
  string s=(char*)args;
  while(true)
  {
    if(tickets>0)
   {
     usleep(10000);
     cout<<s<<" "<<"抢到票了，"<<"票数还剩下："<<--tickets<<endl;
   }
   else
   {
     cout<<"票已经完了"<<" "<<s<<" "<<"退出了"<<endl;
     break;
   }
 }
 return nullptr;
}
int main()
{
  pthread_t tid1;
  pthread_t tid2;
  pthread_t tid3;
  pthread_t tid4;

  pthread_create(&tid1,nullptr,getTickets,(void*)"pthread1");
  pthread_create(&tid2,nullptr,getTickets,(void*)"pthread2");
  pthread_create(&tid3,nullptr,getTickets,(void*)"pthread3");
  pthread_create(&tid4,nullptr,getTickets,(void*)"pthread4");

    int n = pthread_join(tid1, nullptr);
    cout << n << ":" << strerror(n) << endl;
    n = pthread_join(tid2, nullptr);
    cout << n << ":" << strerror(n) << endl;
    n = pthread_join(tid3, nullptr);
    cout << n << ":" << strerror(n) << endl;
    n = pthread_join(tid4, nullptr);
    cout << n << ":" << strerror(n) << endl;
  return 0;
}

结果：

为何票数会出现负数？

原因：变量tickets就是临界资源，因为它被多个执行流同时访，并且tickets--不是原子性的。

--tickets解释

虽然这是一条语句，但它并不是原子性的。所谓原子性：不会被任何调度机制打断的操作，该操作只有两态，要么完成，要么未完成。

--tickets可以分为三步：

取出 ticket-- 部分的汇编代码

objdump -d a.out > test.objdump

152 40064b: 8b 05 e3 04 20 00 mov 0x2004e3(%rip),%eax # 600b34 <ticket>

153 400651: 83 e8 01 sub $0x1,%eax

154 400654: 89 05 da 04 20 00 mov %eax,0x2004da(%rip) # 600b34 <ticket>

load：将共享变量tickets从内存加载到寄存器中。
update：更新寄存器里面的值，执行-1操作。
store：将新值从寄存器写回共享变量tickets的内存地址。

但是当它执行到其中任何一步时，该线程都有可能被中断，另外的线程也可以对该变量进行同样的操作。当线程再次被唤醒将自己寄存器的值写入时，可能该tickets已被多个线程进行了--操作，所以会出现问题。

1.2互斥量mutex

1.大部分情况，线程使用的数据都是局部变量，变量的地址空间在线程栈空间内，这种情况，变量归属单个线程，其他线程无法获得这种变量。

2.若变量都需要在多个线程间共享，这样的变量称为共享变量，可以通过数据的共享，完成线程之间的交互。

3.多个线程并发的操作共享变量，会带来一些问题。

如何利用互斥量解决上面的抢票问题？

上面的tickets就是共享变量，只要保证对该变量进行修改的时候，只有一个线程去修改，其它线程只能去等待。当该线程对该变量的操作完全结束后，再让其它线程进行上述操作。

可以认为这个过程就是加锁--解锁的过程。 Linux 上提供的这把锁叫互斥量。

1.3互斥量接口

初始化互斥量函数：pthread_mutex_init

int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);

参数解释：

mutex：需要初始化的互斥量。
attr：初始化互斥量的属性，一般设置为NULL即可。

调用pthread_mutex_init函数初始化互斥量叫做动态分配，还可以用下面这种方式初始化互斥量，该方式叫做静态分配：

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

销毁互斥量

销毁互斥量的函数：pthread_mutex_destroy

int pthread_mutex_destroy(pthread_mutex_t *mutex);

参数解释：

mutex：需要销毁的互斥量。

补充：

1.使用PTHREAD_MUTEX_INITIALIZER初始化的互斥量不需要销毁。

2.不要销毁一个已经加锁的互斥量。

3.已经销毁的互斥量，要确保后面不会有线程再尝试加锁。

互斥量加锁

互斥量加锁的函数：pthread_mutex_lock

int pthread_mutex_lock(pthread_mutex_t *mutex);

参数解释：

mutex：需要加锁的互斥量

补充：

调用pthread_mutex_lock时，可能会两种情况：

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

互斥量解锁

互斥量解锁函数：pthread_mutex_unlock

int pthread_mutex_unlock(pthread_mutex_t *mutex);

参数解释：

mutex：需要解锁的互斥量

补充：上面几个函数调用成功返回0，失败反回错误码。

代码演示：

int tickets=1000;
pthread_mutex_t mutex;

void* getTickets(void* args)
{
  string s=(char*)args;
  while(true)
  {
    pthread_mutex_lock(&mutex);//加锁
    if(tickets>0)
   {
     usleep(10000);
     cout<<s<<" "<<"抢到票了，"<<"票数还剩下："<<--tickets<<endl;
    pthread_mutex_unlock(&mutex);//解锁
    usleep(10);//模拟业务处理
   }
   else
   {
     cout<<"票已经完了"<<" "<<s<<" "<<"退出了"<<endl;
     pthread_mutex_unlock(&mutex);//解锁
     break;
   }
 }
 return nullptr;
}
int main()
{
  pthread_t tid1;
  pthread_t tid2;
  pthread_t tid3;
  pthread_t tid4;

  pthread_mutex_init(&mutex,nullptr);//初始化互斥量

  pthread_create(&tid1,nullptr,getTickets,(void*)"pthread1");
  pthread_create(&tid2,nullptr,getTickets,(void*)"pthread2");
  pthread_create(&tid3,nullptr,getTickets,(void*)"pthread3");
  pthread_create(&tid4,nullptr,getTickets,(void*)"pthread4");

   int n = pthread_join(tid1, nullptr);
    cout << n << ":" << strerror(n) << endl;
    n = pthread_join(tid2, nullptr);
    cout << n << ":" << strerror(n) << endl;
    n = pthread_join(tid3, nullptr);
    cout << n << ":" << strerror(n) << endl;
    n = pthread_join(tid4, nullptr);
    cout << n << ":" << strerror(n) << endl;
  return 0;
}

结果：

1.4互斥量原理

1.在加锁之后还可以进行线程切换吗？

是可以的，在临界资源对应的临界区中上锁了，临界区还是多行代码，是多行代码就可以被切换。

但是被切换之后的其它线程去访问这块临界资源时会被阻塞挂起，不能对其访问。例如1号线程在切走的时候，绝对不会有其它线程进入临界区。既然不会有其它线程进入临界区，那么其它线程看来，1号线程对该临界区的访问就是原子性的。

2.锁需要被保护吗？

毫无疑问，锁也是被多个执行流竞争的资源，锁本身就是临界资源。既然是临界资源，那么谁来保护锁呢？

其实锁可以自己保护自己，只需要保证申请锁的过程是原子的，那么锁就是安全的。

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

3.如何看待加锁解锁的过程？

看看lock和unlock的伪代码：

我们可以认为mutex的初始值为1，al是计算机中的一个寄存器，开始值为0，当线程申请锁时。

将mutex的值与al中的值进行交换，交换后mutex的值变为了0，后面对该al中的值进行判断，若是1，则该线程申请锁成功，可以进入临界区对临界资源进行访问。若在未解锁之前发生了线程切换，其它线程的也与mutex交换，结果为0，则挂起等待。解锁的过程也是这样，将内存中的mutex置回1，使得下一个申请锁的线程在执行交换指令后能够得到1，唤醒那些因为申请锁失败而被挂起的线程。

二.可重入与线程安全

线程安全 ：多个线程并发同一段代码时，不会出现不同的结果。常见对全局变量或者静态变量进行操作，并且没有锁保护的情况下，会出现该问题。

重入： 同一个函数被不同的执行流调用，当前一个流程还没有执行完，就有其他的执行流再次进入，我们称之为重入。一个函数在重入的情况下，运行结果不会出现任何不同或者任何问题，则该函数被称为可重入函数，否则，是不可重入函数。

常见的线程不安全的情况：

不保护共享变量的函数。

函数状态随着被调用，状态发生变化的函数。

返回指向静态变量指针的函数。

调用线程不安全函数的函数。

常见的线程安全的情况：

每个线程对全局变量或者静态变量只有读取的权限，而没有写入的权限，一般来说这些线程是安全的类或者接口对于线程来说都是原子操作。

多个线程之间的切换不会导致该接口的执行结果存在二义。

常见不可重入的情况：

调用了malloc/free函数，因为malloc函数是用全局链表来管理堆的

调用了标准I/O库函数，标准I/O库的很多实现都以不可重入的方式使用全局数据结构

可重入函数体内使用了静态的数据结构

常见可重入的情况：

不使用全局变量或静态变量。

不使用用malloc或者new开辟出的空间。

不调用不可重入函数。

不返回静态或全局数据，所有数据都有函数的调用者提供。

使用本地数据，或者通过制作全局数据的本地拷贝来保护全局数据。

三.常见锁的概念

死锁概念：

死锁是指在一组进程中的各个进程均占有不会释放的资源，但因互相申请被其他进程所站用不会释放的资源而处于的一种永久等待状态。

死锁四个必要条件：

互斥条件：一个资源每次只能被一个执行流使用

请求与保持条件：一个执行流因请求资源而阻塞时，对已获得的资源保持不放

不剥夺条件 : 一个执行流已获得的资源，在末使用完之前，不能强行剥夺

循环等待条件 : 若干执行流之间形成一种头尾相接的循环等待资源的关系

避免死锁：

破坏死锁的四个必要条件

加锁顺序一致

避免锁未释放的场景

资源一次性分配

四. Linux线程同步

4.1同步概念与竞态条件

同步： 在保证数据安全的前提下，让线程能够按照某种特定的顺序访问临界资源，从而有效避免饥饿问题，叫做同步。

竞态条件： 因为时序问题，而导致程序异常，我们称之为竞态条件。

补充：

1.上面介绍的加锁（互斥量）解决了临界资源安全的问题，保证了只有一个线程对该资源进行访问。但也会存在某些问题的，如果个别线程的竞争力特别强，每次都能够申请到锁，这就可能导致其他线程长时间竞争不到锁，引起饥饿问题。

2.只是简单的加锁没有高效的让每一个线程都使用这份临界资源，还可能导致某些线程饥饿，而同步可以解决这一问题。

4.2条件变量

概念：条件变量是利用线程间共享的全局变量进行同步的一种机制，条件变量是用来描述某种资源是否就绪的一种数据化描述。

条件变量主要包括两个动作：

一个线程等待条件变量的条件成立而被挂起。
另一个线程使条件成立后唤醒等待的线程。

条件变量通常需要配合互斥锁一起使用

初始化条件变量的函数：

pthread_cond_init

int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);

参数解释：

cond：需要初始化的条件变量。
attr：初始化条件变量的属性，一般设置为NULL即可。

调用pthread_cond_init函数初始化条件变量叫做动态分配，除此之外，我们还可以用下面这种方式初始化条件变量，该方式叫做静态分配：

pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

销毁条件变量函数：

pthread_cond_wait

int pthread_cond_destroy(pthread_cond_t *cond);

参数解释：

cond：需要销毁的条件变量。

等待条件变量函数：

int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);

参数解释：

cond：需要等待的条件变量。
mutex：当前线程所处临界区对应的互斥锁。

唤醒等待的函数：

int pthread_cond_broadcast(pthread_cond_t *cond);
int pthread_cond_signal(pthread_cond_t *cond);

pthread_cond_signal函数用于唤醒等待队列中首个线程。
pthread_cond_broadcast函数用于唤醒等待队列中的全部线程。

参数解释：

cond：唤醒在cond条件变量下等待的线程。

代码演示：让主线程创建5个子线程，后面让那5个线程等待，再依次唤醒每一个线程。

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

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
void* Routine(void* argv)
{
  pthread_detach(pthread_self());
  char* name=(char*)argv;
  printf("%s is running\n",name);
  while(1)
  {
    pthread_cond_wait(&cond, &mutex); //阻塞在这里，直到被唤醒
		printf("%s 在工作\n",name);

  }
}

int main()
{
  pthread_t tid1,tid2,tid3,tid4,tid5;
  pthread_create(&tid1,NULL,Routine,(void*)"thread1");
  pthread_create(&tid2,NULL,Routine,(void*)"thread2");
  pthread_create(&tid3,NULL,Routine,(void*)"thread3");
  pthread_create(&tid4,NULL,Routine,(void*)"thread4");
  pthread_create(&tid5,NULL,Routine,(void*)"thread5");
  while(1)
  {
    pthread_cond_signal(&cond);
    sleep(1);
  }
  return 0;
}

结果：5个线程阻塞后，依次被唤醒工作

补充：

等待的时候往往是在临界区内等待的，当该线程进入等待的时候，互斥锁会自动释放，而当该线程被唤醒时，又会自动获得对应的互斥锁。
条件变量需要配合互斥锁使用，其中条件变量是用来完成同步的，而互斥锁是用来完成互斥的。
pthread_cond_wait函数有两个功能，一就是让线程在特定的条件变量下等待，二就是让线程释放对应的互斥锁。

条件变量使用规范：

等待条件变量的代码

pthread_mutex_lock(&mutex);
while (条件为假)
	pthread_cond_wait(&cond, &mutex);
修改条件
pthread_mutex_unlock(&mutex);

唤醒等待线程的代码

pthread_mutex_lock(&mutex);
设置条件为真
pthread_cond_signal(&cond);
pthread_mutex_unlock(&mutex);

"派派"

关注

2
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Linux线程安全

将mutex的值与al中的值进行交换，交换后mutex的值变为了0，后面对该al中的值进行判断，若是1，则该线程申请锁成功，可以进入临界区对临界资源进行访问。解锁的过程也是这样，将内存中的mutex置回1，使得下一个申请锁的线程在执行交换指令后能够得到1，唤醒那些因为申请锁失败而被挂起的线程。1.大部分情况，线程使用的数据都是局部变量，变量的地址空间在线程栈空间内，这种情况，变量归属单个线程，其他线程无法获得这种变量。是可以的，在临界资源对应的临界区中上锁了，临界区还是多行代码，是多行代码就可以被切换。
复制链接

扫一扫