Java 自旋锁(spinlock)相关知识总结

一、前言

谈到『自旋锁』,可能大家会说,这有啥好讲的,不就是等待资源的线程"原地打转"嘛。嗯,字面理解的意思很到位,但能深入具体点吗?自旋锁的设计真就这么简单?

本文或者说本系列的目的,都是让大家不要停留在表面,而是深入分析,做到:

  • 灵活使用
  • 掌握原理
  • 优缺点

二、锁的优化:自旋锁

当多个线程想同时访问同一个资源时,就存在资源冲突,这时,大家最直接想到的就是加锁来互斥访问,加锁会有这么几个问题:

  1. 等待资源的线程进入睡眠,发生用户态向内核态的切换,有一定的性能开销;
  2. 占用资源的线程很快就用完并释放,这时等待的线程被唤醒,又要立即切换回用户态;

那么,如果有一种方式,使得等待的线程先短暂的等待一会儿,有可能有两种结果:

  1. 等待的时间超过了这一会儿,那没办法,只好进入睡眠;
  2. 等待的时间还未超过,占用资源的线程释放了,这时等待的线程就可以直接占用资源。

这就是锁的小优化:自旋锁! 自旋锁并不是真正的锁,而是让等待的线程先原地"小转"一下,小转一下,通常小转一下的实现方式很简单:

int SPIN_LOCK_NUM = 64;
int i = 0;
boolean wait = true;

do {
 wait = // 尝试获取资源锁
} while (wait && (++i) < SPIN_LOCK_NUM);

我们通过循环一定的次数来自旋。 \color{red}{但是我们也应该知道,不进入休眠而原地打转,是会一直消耗 CPU 资源的,因此,才有了自旋限制!}但是我们也应该知道,不进入休眠而原地打转,是会一直消耗CPU资源的,因此,才有了自旋限制!

看下面的JDK源码:

public final class Unsafe {
 public final int getAndSetInt(Object var1, long var2, int var4) {
  int var5;
  do {
   var5 = this.getIntVolatile(var1, var2);
  } while(!this.compareAndSwapInt(var1, var2, var5, var4));

  return var5;
 }
}

我们可以看到,CAS就是采用的自旋锁方式,持续的尝试读取最新的 volatile 修饰的变量的值,并尝试去用期望的值去比较,然后更新。

不过这里我们要注意,因为是无限循环,因此我们要保证占用资源的线程很快就能释放,而不是长时间占用(当然,因为这里的源码系统也设定了 int 型变量,因此,占用该变量的线程很快就会使用完而释放)。

三、自旋锁的死锁

啥?怎么会有死锁? 自旋锁虽然好用,若我们只是停留在上面的分析,那么还是很肤浅的;虽然自旋锁有很大的优势,但同样缺点也不少,除了上面说的,原地打转(忙等待)会一直消耗CPU资源,同时,还会有一个潜在的可能缺陷:死锁。

3.1、系统中断

在聊死锁之前,我们需要先了解一下系统中断事件(大学课本里有这一章节,ASM汇编中也涉及到系统中断向量表):

中断是指,CPU正常运行期间,由于有内/外部事件,或者由程序预先安排的事件,引起CPU暂停当前工作,转而去处理该事件,当处理完该事件后再返回继续运行被中断(暂停)的程序。通常,操作系统将中断分为两类:外部中断(硬件中断)和内部中断(异常中断,即软件引起的);

例如:由IO设备引起的中断为硬件中断,比如,键盘输入,硬盘/光驱读写等;异常中断很好理解,比如 NullPointerException 等。

3.2、中断处理程序

系统提供了一个API使得我们的程序能够向系统申请注册一个中断处理程序(例如:程序接收用户的输入事件)。

request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags, const char *name, void *dev)

参数含义如下:

  • irq: 中断号,系统定义好,具体可查看中断向量表;
  • handler: 中断后发生的ISR(Interrupt Service Routines),直接翻译为:中断服务路由;实际类似,是响应中断服务的程序;
  • flags: 中断标志;
  • name: 中断相关的设备的ASCII,如:"keyboard",这些名字会在 /proc/irq 和 /proc/interrupts 中使用;
  • dev: 用于共享中断线,传递驱动程序的设备结构。非共享类型的中断,直接设置成为 NULL

中断标志(flags):

  • IRQF_DISABLED: 内核处理该ISR期间,禁止其它中断(一般很少使用);
  • IRQF_SAMPLE_RANDOM: 表明该设备产生的中断对内核熵池有贡献;
  • IRQF_TIMER: 系统定时器;
  • IRQF_SHARED: 多个ISR共享中断线,即一个中断,可存在多个ISR;

调用 request_irq 成功时返回0,常见错误是 -EBUSY,表示给定的中断线已经在使用(没有指定IRQF_SHARED)。

注:

  1. 该函数可能引起睡眠,所以不允许在中断上下文或者不允许睡眠的程序中使用!
  2. Linux 中的中断处理程序是无须重入的。当给定的中断处理程序正在执行的时候,其中断线在所有的处理器上都会被屏蔽掉,以防在同一个中断线上又接收到另一个新的中断。通常情况下,除了该中断的其他中断都是打开的,也就是说其他的中断线上的重点都能够被处理,但是当前的中断线总是被禁止的,故,同一个中断处理程序是绝对不会被自己嵌套的。

那这和死锁有何关系呢?额,下一小节会谈到。但这里之所有提到中断,是因为我们还要知道一件事,当系统产生中断,程序被暂停时,程序是不能进入休眠的,此时程序只能采用一种方式:自旋,来保证不会睡眠。

为何不能睡眠?这里就涉及到『中断上下文 context』!

3.3、中断上下文 Context

上面说了,request_irq 可能引起睡眠,所以不允许在中断上下文中使用,也就是说,中断上下文不允许睡眠!

中断上下文:它与进程上下文不一样,中断上下文是内核正在执行ISR。ISR没有自己独立的栈,而是使用内核栈,大小一般是有限制的(32位是8KB大小)。同时,ISR是打断了正常的程序流程,因此必须保证ISR执行速度快。正因为要执行速度快,所以,中断上下文不允许睡眠,且不允许被阻塞!

大家可能会说了,执行速度快不允许睡眠,这解释不合理,我睡眠个1ms不行么?嗯,下面我们就来分析下不能睡眠的真正原因:

1.中断处理时,不会发生进程切换。

  • 因为能打断当前中断的只可能是更高优先级的中断,其它进程的优先级是不会比中断优先级更高的;
  • 如果中断上下文休眠,则没有办法唤醒它,因为所有的 wake_up_xxx 是针对进程而言,而中断没有进程的概念;
  • 只要是中断(硬中or软中,不是香烟),都发生在内核,如果中断上下文睡眠了,内核就阻塞了,系统能阻塞么?不能!阻塞了你就只能重启机器了;

2.schedule 在切换进程时,会保存当前的进程上下文(CPU寄存器的值、状态、堆栈SP内容)以便以后恢复再运行。中断发生后,内核会保存当前被中断进程的上下文。在ISR中,是中断上下文,如果休眠或阻塞,则会调用 schedule,保存的进程上下文不是当前进程的上下文,所以不能在ISR中调用 schedule;
3.内核中 schedule 在进入时会判断是否处于中断上下文:

if(unlikely(in_interrupt()))) ..... crash!!!

4.中断 handler 会使用被中断的进程内核堆栈,但不会对其有任何影响,因为 handler用之前会保存,用完后会清除并恢复原貌;
5.处理中断上下文中,内核是不可抢占的,如果休眠,则内核....一定会被挂起,同样,你只能重启机器了;
所以,被中断的程序也不能睡眠!那么只能使用『自旋锁』来原地打转。

那还是没有说自旋为何会死锁?

自旋锁是不能递归,否则自己等待自己已经获取的锁,将会导致死锁!

一个线程获取了一个自旋锁,在执行这程中被中断处理程序打断,因此该线程只是暂停执行,并未退出,仍持有自旋锁;而中断处理程序尝试获取自旋锁而获取不到,只能自旋;这就造成一个事实:ISR拿不到自旋锁,导致自旋而无法退出,该线程被中断无法恢复执行至退出释放自旋锁,此时就造成了死锁,导致系统崩溃。

四、死锁解决

发生自旋锁死锁,往往因为单CPU这个临界资源发生了抢占,使得一方持有自旋锁被中断暂停,一方不断自旋来尝试获取自旋锁。因此,在多CPU架构下,两方如果分别运行在不同CPU上,是不会发生死锁的。

因此,自旋锁有几个重要特性需要掌握(精髓):

  • 持有自旋锁的线程(此时肯定在临界区)不能休眠,休眠会引起进程切换,CPU就会被另一个进程占用等无法使用;
  • 持有自旋锁的线程不允许被中断,哪怕是ISR也不行,否则就存在ISR自旋;
  • 持有自旋锁的线程,其内核不能被抢占,否则等同于CPU被抢占;

所以,根据以上总结一点:持有自旋锁的线程,不能因为任何原因而放弃CPU! 也因此基于上述问题,自旋也需要添加一个上限时间以防死锁。

linux上的自旋锁有三种实现:

  1. 在单cpu,不可抢占内核中,自旋锁为空操作。
  2. 在单cpu,可抢占内核中,自旋锁实现为“禁止内核抢占”,并不实现“自旋”。(注意)
  3. 在多cpu,可抢占内核中,自旋锁实现为“禁止内核抢占” + “自旋”。

以上就是Java 自旋锁(spinlock)相关知识总结的详细内容,更多关于Java 自旋锁(spinlock)的资料请关注我们其它相关文章!

(0)

相关推荐

  • 实例讲解Java 自旋锁

    一直以来不是怎么清楚自旋锁,最近有点时间,好好的学习了一下: 所谓的自旋锁在我的理解就是多个线程在尝试获取锁的时候,其中一个线程获取锁之后,其他的线程都处在一直尝试获取锁的状态,不会阻塞!!!那么什么叫做一直尝试获取锁呢?就是一个循环,比较经典的是AtomicInteger中的一个updateAndGet方法,下图所示(当然也可以直接看unsafe类中的getAndAddInt等类似方法): 我们可以看出在while循环中使用CAS去尝试更新一个变量,如果更新失败,就会一直在这个循环中一直在尝试

  • 一篇文章轻松搞懂Java中的自旋锁

    前言 锁作为并发共享数据,保证一致性的工具,在JAVA平台有多种实现(如 synchronized 和 ReentrantLock等等 ) .这些已经写好提供的锁为我们开发提供了便利. 在之前的文章<一文彻底搞懂面试中常问的各种"锁" >中介绍了Java中的各种"锁",可能对于不是很了解这些概念的同学来说会觉得有点绕,所以我决定拆分出来,逐步详细的介绍一下这些锁的来龙去脉,那么这篇文章就先来会一会"自旋锁". 正文 出现原因 在我们的

  • 深入理解java自旋锁

    简单回顾一下CAS算法 CAS算法 即compare and swap(比较与交换),是一种有名的无锁算法.无锁编程,即不使用锁的情况下实现多线程之间的变量同步,也就是在没有线程被阻塞的情况下实现变量的同步,所以也叫非阻塞同步(Non-blocking Synchronization).CAS算法涉及到三个操作数 需要读写的内存值 V 进行比较的值 A 拟写入的新值 B 当且仅当 V 的值等于 A时,CAS通过原子方式用新值B来更新V的值,否则不会执行任何操作(比较和替换是一个原子操作).一般情

  • Java锁之自旋锁详解

    锁作为并发共享数据,保证一致性的工具,在JAVA平台有多种实现(如 synchronized 和 ReentrantLock等等 ) .这些已经写好提供的锁为我们开发提供了便利,但是锁的具体性质以及类型却很少被提及.本系列文章将分析JAVA下常见的锁名称以及特性,为大家答疑解惑. 1.自旋锁 自旋锁是采用让当前线程不停地的在循环体内执行实现的,当循环的条件被其他线程改变时 才能进入临界区.如下 复制代码 代码如下: public class SpinLock { private AtomicRe

  • Java 自旋锁(spinlock)相关知识总结

    一.前言 谈到『自旋锁』,可能大家会说,这有啥好讲的,不就是等待资源的线程"原地打转"嘛.嗯,字面理解的意思很到位,但能深入具体点吗?自旋锁的设计真就这么简单? 本文或者说本系列的目的,都是让大家不要停留在表面,而是深入分析,做到: 灵活使用 掌握原理 优缺点 二.锁的优化:自旋锁 当多个线程想同时访问同一个资源时,就存在资源冲突,这时,大家最直接想到的就是加锁来互斥访问,加锁会有这么几个问题: 等待资源的线程进入睡眠,发生用户态向内核态的切换,有一定的性能开销: 占用资源的线程很快就

  • 深入理解Java显式锁的相关知识

    目录 一.显式锁 二.Lock的常用api 三.Lock的标准用法 四.ReentrantLock(可重入锁) 五.ReentrantReadWriteLock(读写锁) 六.Condition 一.显式锁 什么是显式锁? 由自己手动获取锁,然后手动释放的锁. 有了 synchronized(内置锁) 为什么还要 Lock(显示锁)? 使用 synchronized 关键字实现了锁功能的,使用 synchronized 关键字将会隐式地获取锁,但是它将锁的获取和释放固化了,也就是先获取再释放.

  • java自旋锁和JVM对锁的优化详解

    目录 背景 好处 AtomicLong的实现 getAndIncrement方法 实验 缺点 适用场景 JVM对锁做了哪些优化? 自适应的自旋锁 锁消除 锁粗化 偏向锁/ 轻量级锁/ 重量级锁 锁升级 背景 先上图 由此可见,非自旋锁如果拿不到锁会把线程阻塞,直到被唤醒: 自旋锁拿不到锁会一直尝试 为什么要这样? 好处 阻塞和唤醒线程都是需要高昂的开销的,如果同步代码块中的内容不复杂,那么可能转换线程带来的开销比实际业务代码执行的开销还要大. 在很多场景下,可能我们的同步代码块的内容并不多,所以

  • Java基础之并发相关知识总结

    一.Java并发是什么? 用学术定义来说就是 并发:同一时间段,多个任务都在执行 (单位时间内不一定同时执行): 简单来说就是,同一个时间段,让计算机同时做多个事情. 说到并发,不得不提就是并行: 并行:单位时间内,多个任务同时执行. 两者大眼一看很像,仔细一想却并不相同,因为并行强调某个时间点多个任务同时执行,而并发强调的是一个时间段内多个任务都在执行. 二.怎么做? 大部分并发问题,最终都可以抽象成三类问题分工.同步和互斥.而且针对不同的问题有着不同的方式来解决,具体如下图所示: 三.分工

  • 什么是Java自旋锁

    目录 1.自旋锁 2.工作流程 3.缺点 4.实现原理 5.自适应自旋 前言: 阻塞或唤醒一个Java线程需要操作系统切换CPU状态来完成,这种状态转换需要耗费处理器时间.如果同步代码块中的内容过于简单,状态转换消耗的时间有可能比用户代码执行的时间还要长. 1.自旋锁 在有些场景中,同步资源的锁定时间很短,为了这一小段时间去切换线程,线程挂起和恢复现场的花费可能会让系统得不偿失. 如果机器有多个CPU核心,能够让两个或以上的线程同时并行执行,我们就可以让后面那个请求锁的线程不放弃CPU的执行时间

  • Golang自旋锁的相关介绍

    目录 自旋锁 golang实现自旋锁 可重入的自旋锁和不可重入的自旋锁 自旋锁的其他变种 1. TicketLock 2. CLHLock 3. MCSLock 4. CLHLock 和 MCSLock 自旋锁与互斥锁 总结 自旋锁 获取锁的线程一直处于活跃状态,但是并没有执行任何有效的任务,使用这种锁会造成busy-waiting. 它是为实现保护共享资源而提出的一种锁机制.其实,自旋锁与互斥锁比较类似,它们都是为了解决某项资源的互斥使用.无论是互斥锁,还是自旋锁,在任何时刻,最多只能由一个保

  • java中数组的相关知识小结(推荐)

    1. 2.数组的命名方法 1)int[]ages=new int[5]; 2) int[]ages; ages=new int[5]; 3)int[]ags={1,2,3,4,5}; 4)int[]ags; ags=new int{1,2,3,4}; 或者 int[]ags=new int{1,2,3,4}; 3.java不支持不同类型的重名数组 4.java中数组的循环赋值 package dierge; public class Shuzu { public static void main

  • MySQL 锁的相关知识总结

    MySQL中的锁 锁是为了解决并发环境下资源竞争的手段,其中乐观并发控制,悲观并发控制和多版本并发控制是数据库并发控制主要采用的技术手段(具体可见我之前的文章),而MySQL中的锁就是其中的悲观并发控制. MySQL中的锁有很多种类,我们可以按照下面方式来进行分类. 按读写 从数据库的读写的角度来分,数据库的锁可以分为分为以下几种: 独占锁:又称排它锁.X锁.写锁.X锁不能和其他锁兼容,只要有事务对数据上加了任何锁,其他事务就不能对这些数据再放置X了,同时某个事务放置了X锁之后,其他事务就不能再

  • Java基础之引用相关知识总结

    一.引用的定义 在JDK 1.2以前,Java中的引用定义很传统:如果reference类型的数据存储的数值代表的是另外一块内存的起始地址,就称这块内存代表着一个引用. 二.问题 当描述这样的一类对象:当内存空间还足够时,则能保留在内存之中,如果内存空间在进行垃圾收集后还是非常紧张,则可以抛弃这些对象.此时的引用就显得过于狭隘.因此在JDK 1.2之后,Java堆引用的概念进行了扩充. 三.引用的分类 回收时机 强引用 Strong Reference 类似Object obj = new Ob

随机推荐