并发编程11:Synchronized与锁升级

这篇具有很好参考价值的文章主要介绍了并发编程11:Synchronized与锁升级。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

11.1 面试题

  • 谈谈你对Synchronized的理解
  • Sychronized的锁升级你聊聊
  • Synchronized实现原理,monitor对象什么时候生成的?知道monitor的monitorenter和monitorexit这两个是怎么保证同步的嘛?或者说这两个操作计算机底层是如何执行的
  • 偏向锁和轻量级锁有什么区别

11.2 Synchronized的性能变化

  • Java5以前,只有Synchronized,这个是操作系统级别的重量级操作

    • 重量级锁,假如锁的竞争比较激烈的话,性能下降
    • Java 5之前 用户态和内核态之间的转换
      并发编程11:Synchronized与锁升级
  • Java6 之后为了减少获得锁和释放锁所带来的性能消耗,引入了轻量级锁和偏向锁

11.3 Synchronized锁种类及升级步骤

11.3.1 多线程访问情况

  • 只有一个线程来访问,有且唯一Only One
  • 有两个线程(2个线程交替访问)
  • 竞争激烈,更多线程来访问

11.3.2 升级流程

  • Synchronized用的锁是存在Java对象头里的MarkWord中,锁升级功能主要依赖MarkWord中锁标志位和释放偏向锁标志位
    并发编程11:Synchronized与锁升级

  • 锁指向,请牢记

    • 偏向锁:MarkWord存储的是偏向的线程ID
    • 轻量锁:MarkWord存储的是指向线程栈中Lock Record的指针
    • 重量锁:MarkWord存储的是指向堆中的monitor对象(系统互斥量指针)

11.3.3 无锁

并发编程11:Synchronized与锁升级

11.3.4 偏锁

偏向锁:单线程竞争,当线程A第一次竞争到锁时,通过修改MarkWord中的偏向线程ID、偏向模式。如果不存在其他线程竞争,那么持有偏向锁的线程将永远不需要进行同步
主要作用:

  • 当一段同步代码一直被同一个线程多次访问,由于只有一个线程那么该线程在后续访问时便会自动获得锁
  • 同一个老顾客来访,直接老规矩行方便
    结论:
  • HotSpot的作者经过研究发现,大多数情况下:在多线程情况下,锁不仅不存在多线程竞争,还存在由同一个线程多次获得的情况,偏向锁就是在这种情况下出现的,它的出现是为了解决只有一个线程执行同步时提高性能
  • 偏向锁会偏向于第一个访问锁的线程,如果在接下来的运行过程中,该锁没有被其他线程访问,则持有偏向锁的线程将永远不需要出发同步。也即偏向锁在资源在没有竞争情况下消除了同步语句,懒得连CAS操作都不做了,直接提高程序性能。
    理论落地:
    并发编程11:Synchronized与锁升级

技术实现:
并发编程11:Synchronized与锁升级

偏向锁JVM命令:
并发编程11:Synchronized与锁升级

案例演示:

  • 偏向锁默认情况演示—只有一个线程
public class SynchronizedUpDemo {

    public static void main(String[] args) {
        /**
         * 这里偏向锁在JDK6以上默认开启,开启后程序启动几秒后才会被激活,可以通过JVM参数来关闭延迟 -XX:BiasedLockingStartupDelay=0
         */
//        try { TimeUnit.SECONDS.sleep(5); } catch (InterruptedException e) { e.printStackTrace(); }
        Object o = new Object();
        synchronized (o) {
            System.out.println(ClassLayout.parseInstance(o).toPrintable());
        }
    }
}

并发编程11:Synchronized与锁升级

偏向锁的撤销:

  • 当有另外一个线程逐步来竞争锁的时候,就不能再使用偏向锁了,要升级为轻量级锁,使用的是等到竞争出现才释放锁的机制
  • 竞争线程尝试CAS更新对象头失败,会等到全局安全点此时不会执行任何代码)撤销偏向锁,同时检查持有偏向锁的线程是否还在执行:
    • 第一个线程正在执行Synchronized方法(处于同步块),它还没有执行完,其他线程来抢夺,该偏向锁会被取消掉并出现锁升级,此时轻量级锁由原来持有偏向锁的线程持有,继续执行同步代码块,而正在竞争的线程会自动进入自旋等待获得该轻量级锁
    • 第一个线程执行完Synchronized(退出同步块),则将对象头设置为无所状态并撤销偏向锁,重新偏向。
      并发编程11:Synchronized与锁升级

题外话:Java15以后逐步废弃偏向锁,需要手动开启------->维护成本高

11.3.5 轻锁

概念:多线程竞争,但是任意时候最多只有一个线程竞争,即不存在锁竞争太激烈的情况,也就没有线程阻塞。
主要作用:有线程来参与锁的竞争,但是获取锁的冲突时间极短---------->本质是自旋锁CAS
并发编程11:Synchronized与锁升级

轻量锁的获取:
并发编程11:Synchronized与锁升级
并发编程11:Synchronized与锁升级

案例演示:
并发编程11:Synchronized与锁升级

自旋一定程度和次数(Java8 之后是自适应自旋锁------意味着自旋的次数不是固定不变的):

  • 线程如果自旋成功了,那下次自旋的最大次数会增加,因为JVM认为既然上次成功了,那么这一次也大概率会成功
  • 如果很少会自选成功,那么下次会减少自旋的次数甚至不自旋,避免CPU空转

轻量锁和偏向锁的区别:

  • 争夺轻量锁失败时,自旋尝试抢占锁
  • 轻量级锁每次退出同步块都需要释放锁,而偏向锁是在竞争发生时才释放锁

11.3.6 重锁

有大量线程参与锁的竞争,冲突性很高
并发编程11:Synchronized与锁升级
并发编程11:Synchronized与锁升级

11.3.7 小总结

  • 锁升级的过程
    并发编程11:Synchronized与锁升级

  • 锁升级后,hashcode去哪儿了?
    并发编程11:Synchronized与锁升级
    并发编程11:Synchronized与锁升级

  • 各种锁优缺点、synchronized锁升级和实现原理
    并发编程11:Synchronized与锁升级

11.4 JIT编译器对锁的优化

11.4.1 JIT

Just In Time Compiler 即时编译器

11.4.2 锁消除

/**
 * 锁消除
 * 从JIT角度看想相当于无视他,synchronized(o)不存在了
 * 这个锁对象并没有被共用扩散到其他线程使用
 * 极端的说就是根本没有加锁对象的底层机器码,消除了锁的使用
 */

public class LockClearUpDemo {
    static Object object = new Object();

    public void m1() {
        //锁消除问题,JIT会无视它,synchronized(o)每次new出来的,都不存在了,非正常的
        Object o = new Object();
        synchronized (o) {
            System.out.println("-----------hello LockClearUpDemo" + "\t" + o.hashCode() + "\t" + object.hashCode());
        }
    }

    public static void main(String[] args) {
        LockClearUpDemo lockClearUpDemo = new LockClearUpDemo();
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                lockClearUpDemo.m1();
            }, String.valueOf(i)).start();
        }
    }
}
/**
 * -----------hello LockClearUpDemo	229465744	57319765
 * -----------hello LockClearUpDemo	219013680	57319765
 * -----------hello LockClearUpDemo	1109337020	57319765
 * -----------hello LockClearUpDemo	94808467	57319765
 * -----------hello LockClearUpDemo	973369600	57319765
 * -----------hello LockClearUpDemo	64667370	57319765
 * -----------hello LockClearUpDemo	1201983305	57319765
 * -----------hello LockClearUpDemo	573110659	57319765
 * -----------hello LockClearUpDemo	1863380256	57319765
 * -----------hello LockClearUpDemo	1119787251	57319765
 */

11.4.3 锁粗化

/**
 * 锁粗化
 * 假如方法中首尾相接,前后相邻的都是同一个锁对象,那JIT编译器会把这几个synchronized块合并为一个大块
 * 加粗加大范围,一次申请锁使用即可,避免次次的申请和释放锁,提高了性能
 */
public class LockBigDemo {
    static Object objectLock = new Object();

    public static void main(String[] args) {
        new Thread(() -> {
            synchronized (objectLock) {
                System.out.println("111111111111");
            }
            synchronized (objectLock) {
                System.out.println("222222222222");
            }
            synchronized (objectLock) {
                System.out.println("333333333333");
            }
            synchronized (objectLock) {
                System.out.println("444444444444");
            }
            //底层JIT的锁粗化优化
            synchronized (objectLock) {
                System.out.println("111111111111");
                System.out.println("222222222222");
                System.out.println("333333333333");
                System.out.println("444444444444");
            }
        }, "t1").start();
    }
}

11.5 小总结

没有锁:自由自在
偏向锁:一个线程
轻量锁:两个线程,CAS
重量锁:多个线程,阻塞文章来源地址https://www.toymoban.com/news/detail-444396.html

到了这里,关于并发编程11:Synchronized与锁升级的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【Java 并发编程】一文详解 Java 内置锁 synchronized

    存在共享数据; 多线程共同操作共享数。 synchronized 可以保证在同一时刻,只有一个线程可以执行某个方法或某个代码块,同时 synchronized 可以保证一个线程的变化可见(可见性),即可以代替 volatile。 多线程编程中,有可能会出现多个线程同时访问同一个共享、可变

    2024年02月02日
    浏览(35)
  • JUC并发编程-线程和进程、Synchronized 和 Lock、生产者和消费者问题

    源码 + 官方文档 面试高频问! java.util 工具包、包、分类 业务:普通的线程代码 Thread Runnable Runnable 没有返回值、效率相比入 Callable 相对较低! 线程、进程,如果不能使用一句话说出来的技术,不扎实! 进程:一个程序,QQ.exe Music.exe 程序的集合; 一个进程往往可以包含多

    2024年01月20日
    浏览(51)
  • 谈谈你对倒排索引的理解

    谈谈你对倒排索引的理解 在聊倒排索引之前,我们需要先了解一下‘索引’概念。 什么是索引呢? 索引是为了加速对表中数据行的检索而创建的一种分散的存储结构 。 通俗的来讲索引好比就是 新华字段中拼音的首字母还有偏旁 ,根据拼音的首字母和偏旁能很快的查找到你

    2024年02月07日
    浏览(38)
  • 18.谈谈你对JSON的理解

    JSON 是一种 基于文本的轻量级的数据交换格式 。它可以被 任何的编程语言读取 和作为 数据格式 来传递。 在项目开发中,使用 JSON 作为前后端数据交换的方式 。在前端通过将一个符合 JSON 格式的数据结构序列化为 JSON 字符串,然后将它传递到后端,后端通过 JSON 格式的字符

    2024年02月22日
    浏览(44)
  • 【面经】谈谈你对FastDFS的了解

    2024年02月06日
    浏览(40)
  • 谈谈你对 Spring AOP 的理解

    Java面试目录 谈谈你对 Spring AOP 的理解 Spring AOP是面向切面编程,通过代理模式来实现。 我们将与业务逻辑无关,同时又需要在业务执行前后调用的逻辑封装起来,利用代理来进行统一调度。可以减少系统的重复代码,降低耦合度,增加可维护性。使用场景包括:事务处理,

    2024年01月22日
    浏览(47)
  • 让我们谈谈你对 ThreadLocal 的理解

    从 JDK1.2 开始,ThreadLocal 是一个被用来存储线程本地变量的类。在 ThreadLocal 中的变量在线程之间是独立的。当多个线程访问 ThreadLocal 中的变量,它们事实上访问的是自己当前线程在内存中的变量,这能确保这些变量是线程安全的。 我们通常使用 ThreadLocal 解决线程中的变量冲

    2023年04月16日
    浏览(38)
  • 【面试题】谈谈你对IOC和AOP的理解

    IoC(Inverse of Control:控制反转)是一种设计思想,就是将 原本在程序中手动创建对象的控制权,交由Spring框架来管理 。IOC思想是基于IOC容器来完成的,IOC容器底层就是对象工厂(BeanFactory接口)。IOC的原理是基于xml解析、工厂设计模式、反射来实现的。 IoC 容器实际上就是个

    2024年02月05日
    浏览(79)
  • 1、什么是面向对象?谈谈你对面向对象的理解

    对比面向过程,是两种不同的处理问题的角度 面向过程更注重事情的每一个步骤及顺序,面向对象更注重事情有哪些参与者(对象)、及各自需要做什么 比如 : 洗衣机洗衣服 面向过程会将任务拆解成一系列的步骤(函数),1、打开洗衣机 …2、放衣服…3、放洗衣粉…4、清洗…

    2024年02月13日
    浏览(42)
  • 【面试八股文】每日一题:谈谈你对异常的理解

    每日一题-Java核心-谈谈你对异常的理解【面试八股文】   异常是程序在运行过程中出现的错误或不正常的情况。当程序执行过程中遇到无法处理的错误或者不符合预期的情况,就会抛出异常。异常可以分为两种类型: 受检异常 和 非受检异常 。    受检异常 是指在程序

    2024年02月13日
    浏览(56)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包