首页 > 其他分享 >【线程安全】线程互斥的原理

【线程安全】线程互斥的原理

时间：2024-07-11 23:56:40浏览次数：12  
标签：互斥 线程 pthread mutex ticket NULL 原理

文章目录

Linux线程互斥

线程互斥（Mutual Exclusion）是多线程编程中的一个重要概念，用于解决多个线程同时访问共享资源时可能产生的竞争条件（Race Condition）和数据不一致问题。

在深入探索Linux线程互斥之前先了解一些基本概念

线程互斥相关概念

  • 临界资源：多线程执行流共享的资源就叫做临界资源
  • 临界区：每个线程内部访问临界资源的代码片段，就叫做临界区
  • 互斥：任何时刻，互斥保证只有一个执行流进入临界区，访问临界资源，是保障临界资源安全的重要手段
  • 原子性：跟MySQL中事务的原子性一样，如果某种操作只有要么完成要么没完成两种状态，我们就称这种操作是原子性的。在这里原子性保证线程的某种操作不会被任何调度机制打断。
  • 竞争条件：多个线程一起访问同一个共享资源，可能会导致不确定的结果。线程之间的这种关系就成为竞争，这种现象就称为竞争条件。

互斥量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;
        }
    }
    return arg;
}

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);
    pthread_join(t3, NULL);
    pthread_join(t4, NULL);
}

全局变量ticket作为临界资源被多个线程同时访问，看看代码的运行结果：

  • 结果片段1
    在这里插入图片描述
  • 结果片段二
    在这里插入图片描述

引出线程并发问题

根据以上代码，我们提出以下疑问：

  1. 为什么多个线程会抢到同一张票？
  2. 为什么票数会出现负数？

我们来看上面的代码中的核心片段：

if (ticket > 0)
{
  usleep(1000);
  printf("%s sells ticket:%d\n", id, ticket);
  ticket--;
}
  • 在if判断结束之后，代码可以并发的切换到其它的线程，这样一来，很有可能当前线程还没有执行ticket--这个操作，其它线程就进来了。这就是为什么会有多个线程抢到同一张票的原因。
  • 同样的，多个线程抢到同一张票，并依次执行ticket--，最终出现票数为负数的情况。简单来说就是，if判断与ticket--，两个操作中间并不是“无缝的”。
  • ticket-- 操作本身就不是一个原子操作，--操作并非是一条汇编语句，而是三条汇编语句的集合。
    • load ：将共享变量ticket从内存加载到寄存器中
    • update : 更新寄存器里面的值，执行-1操作
    • store ：将新值，从寄存器写回共享变量ticket的内存地址

要解决上面线程并发带来的问题需要做到以下几点：

  • 线程访问临界区必须是互斥的，即一个线程访问临界区时其它线程阻塞。
  • 如果线程没有访问临界区，那么该线程不能阻止其它线程进入临界区。

引出互斥锁、互斥量

要想做到一个线程访问临界区时阻止其它线程访问，我们就需要使用到互斥锁机制。锁，顾名思义就是锁上临界区不让其它线程进去。而实现互斥锁机制就需要用到互斥量。这里需要注意互斥锁和互斥量两个名词的区分：

  • 互斥量是一个数据结构或对象，通常包含了锁的状态信息，是否被锁定等
  • 互斥锁是互斥量的操作机制，通过互斥锁操作，线程可以在进入临界区之前锁定互斥量，退出临界区时解锁互斥量。这也对应着我们常说的上锁和解锁两个操作。

为了方便阐述，后面出现的锁和互斥量不做过多区分。

在这里插入图片描述
上图中表示使用互斥锁实现线程互斥的示意图，lock表示上锁()，上锁之后其他线程不能访问临界区，unlock表示解锁，解锁之后其他线程才可以继续申请上锁。下面解释上锁是原子操作的原理：

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

加锁的具体步骤：

  1. 初始化互斥锁，初始化通常在声明时完成

  2. 申请获取锁：

    • 检查锁的状态，如果是空闲状态则继续执行锁操作，否则就阻塞等待
    • 在汇编层面上使用xchgb指令（作用和swap一样）,交换寄存器和内存中的互斥量状态数据，假设置1，使得申请到锁之后该线程能访问临界资源。而由于此时内存中互斥量的状态为0，其它线程无法申请锁就失败了。

  3. 访问临界区

  4. 释放锁

互斥量的接口

初始化互斥量

  • 静态分配：
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER
  • 动态分配：
#include <pthread.h>
int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);

其中pthread_mutex_t *mutex：指向需要初始化的互斥锁对象的指针。
const pthread_mutexattr_t *attr：指向互斥锁属性对象的指针。如果传入NULL，则使用默认属性。

销毁互斥量

如果要销毁一个互斥量可以执行以下代码：

#include <pthread.h>
int pthread_mutex_destroy(pthread_mutex_t *mutex)；

注意：

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

互斥量加锁和解锁

int pthread_mutex_lock(pthread_mutex_t *mutex); //加锁
int pthread_mutex_unlock(pthread_mutex_t *mutex); //解锁

对某个互斥量进行加锁或者解锁，成功返回0，失败返回错误码
具体的，调用pthread_lock时，可能会遇到以下情况：

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

使用互斥锁抢票

了解了互斥的原理以及相关的操作之后，我们可以对上面的样例代码做出以下改进：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <sched.h>

int ticket = 100;
pthread_mutex_t mutex;//声明互斥量

void *route(void *arg)
{
    char *id = (char *)arg;
    while (1)
    {
        pthread_mutex_lock(&mutex);//访问临界区之前申请锁
        if (ticket > 0)
        {
            usleep(1000);
            printf("%s sells ticket:%d\n", id, ticket);
            ticket--;
            pthread_mutex_unlock(&mutex);//访问结束之后释放锁
            // sched_yield(); 放弃CPU
        }
        else
        {
            pthread_mutex_unlock(&mutex);
            break;
        }
    }
    return arg;
}

int main(void)
{
    pthread_t t1, t2, t3, t4;

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

    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);
    pthread_join(t3, NULL);
    pthread_join(t4, NULL);
    pthread_mutex_destroy(&mutex);//主动销毁互斥量
}

观察结果：
在这里插入图片描述
在这里插入图片描述

可重入和线程安全

概念：

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

常见线程不安全的情况

  • 不保护共享变量的函数
  • 函数状态随着被调用，状态发生变化
  • 返回指向静态变量指针的函数
  • 调用线程不安全的函数

常见线程安全的情况

  • 每个线程对全局变量或者静态变量只有读取的权限，而没有写入的权限，一般来说这些线程是安全的
  • 类或者接口对于线程来说都是原子操作
  • 多个线程之间的切换不会导致该接口的执行结果存在二义性

常见不可重入的情况

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

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

常见可重入情况

  • 不使用全局变量或静态变量
  • 不使用用malloc或者new开辟出的空间
  • 不调用不可重入函数

可重入与线程安全联系

  • 函数是可重入的，那就是线程安全的
  • 函数不可重入不代表一定会引发线程安全问题
  • 如果一个函数中有全局变量且尝试修改，那么这个函数既不是可重入，也不是线程安全的
  • 可重入函数是线程安全函数的一种

标签：互斥,线程,pthread,mutex,ticket,NULL,原理
From： https://blog.csdn.net/qq_62987647/article/details/140286977

相关文章

  • 前端必会原理--事件循环
    事件循环浏览器的进程模型何为进程？程序运行需要有它自己专属的内存空间，可以把这块内存空间简单的理解为进程每个应用至少有一个进程，进程之间相互独立，即使要通信，也需要双方同意。何为线程？有了进程后，就可以运行程序的代码了。运行代码的「人」称之为「线程」。一个进......
  • GRE详解：概念、架构、原理、搭建过程、常用命令与实战案例
       我们将深入探讨如何在Linux上设置GRE（GenericRoutingEncapsulation，通用路由封装）。本文将涵盖GRE的定义、架构、原理、应用场景、常见命令体系，并通过详细的实战模拟展示如何在Linux系统上实际操作。希望通过这篇文章，您能深入理解GRE技术，并能在实际中应用。......
  • 关于线程池的两种创建方式
    1.第一种方式Executors工具类固定大小线程池：newFixedThreadPool单一线程池：newSingleThreadExecutor可变线程池：newCachedThreadPool调度线程池:newScheduledThreadPool1.1单一线程池该线程池只有一个线程，适用于需要按任务执行线程场景，保证任务的顺序性//创建应该单一线......
  • 状态同步和帧同步原理细节
    状态同步（StateSynchronization）状态同步是一种基于服务器的同步机制，其中服务器周期性地将游戏状态（如玩家位置、物体状态等）发送给客户端，客户端根据接收到的状态进行更新。原理服务器状态更新：服务器持续更新游戏状态，并以固定时间间隔将状态发送给所有客户端。客户端状态接......
  • Java中线程池的最佳实践
    一、使用正确的声明方式线程池必须手动通过ThreadPoolExecutor的构造函数来声明，避免使用Executors类创建线程池，会有OOM风险。Executors创建的线程池对象有以下弊端：FixedThreadPool和SingleThreadExecutor使用的是有界阻塞队列LinkedBlockingQueue，任务队列的默认长度和......
  • Java多线程&并发编程（二）
    一、CyclicBarrier、CountDownLatch、Semaphore的区别CyclicBarrier的某个线程运行到某个点上之后，该线程即停止运行，直到所有的线程都到达了这个点，所有线程才重新运行（类似于一个栅栏拦住所有线程直到所有线程到达后在重新执行）CountDownLatch则不是，某线程运行到某个点上之后，......
  • 请详述ppo和dpo的区别和优劣|详解ppo原理|
    请详述ppo和dpo的区别和优劣AnswerPPO(ProximalPolicyOptimization)和DPO(DirectPreferenceOptimization)是两种用于大型语言模型对齐的算法，它们有以下主要区别和各自的优缺点：主要区别：训练流程：PPO采用多阶段训练：先训练奖励模型，再使用强化学习优化策略。DPO将......
  • Java异步判断线程池所有任务是否执行完成的方法
    1.使用ExecutorService和CountDownLatch的方法示例在Java中，当我们使用线程池（如ExecutorService）来执行异步任务时，常常需要知道所有任务是否都已经完成。ExecutorService接口提供了几种方式来处理这种情况，但最常用的是shutdown()和awaitTermination()方法的组合，或者使用Future和Com......
  • Linux设备驱动器 之二 线程同步第二篇
    Linux设备驱动器之二线程同步第二篇mutex数据结构LinuxAPIs在Linux驱动器中的应用NXPfreescale系列QSPI驱动器变量定义初始化存取数据semaphore数据结构LinuxAPIs在Linux驱动器中的应用ELAN的Uxxx系列驱动器变量定义初始化同步操作mutex数据结构stru......
  • K8S各组件概念以及原理知识总结
    简述ETCD及其特点？ etcd是CoreOS团队发起的开源项目，是一个管理配置信息和服务发现（servicediscovery）的项目，它的目标是构建一个高可用的分布式键值（key-value）数据库，基于Go语言实现。特点：简单：支持REST风格的HTTP+JSONAPI安全：支持HTTPS方式的访问快速：支持并......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99