synchoronized锁升级实践

已于 2022-04-05 19:00:06 修改
阅读量453 收藏
点赞数
分类专栏： 锁升级 文章标签： java
于 2022-04-05 18:53:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60552721/article/details/123972995
版权

对象内部结构

偏向锁：会把加锁线程的id（threadId 【54bit】）写入到对象头的mark word里面

对象结构说明

对象需先启用为偏向锁才能升级变为偏向锁，偏向锁不会主动释放

偏向锁->轻量级锁：有线程加锁，之后只要有其他线程来争锁，偏向锁立刻会升级为轻量级锁

轻量级锁->重量级锁：多个线程来竞争，当线程不断地CAS自旋都拿不到锁，达到一定自旋次数，才转化为重量级锁。

升级为重量级锁后，指针指向monitor

锁升级实践 

引入依赖

        <!--  帮助打印对象内部的组成结构-->
        <dependency>
            <groupId>org.openjdk.jol</groupId>
            <artifactId>jol-core</artifactId>
            <version>0.10</version>
        </dependency>
public class LockUpgrade {
    public static void main(String[] args) throws InterruptedException {
        User user = new User();
        System.out.println("无状态(001): "+ ClassLayout.parseInstance(user).toPrintable());

        /*java默认延时4s后自动开启偏向锁，可通过  -XX:BiasedLockingStarttupDelay=0 取消延时；
        如果不要偏向锁，可通过 -XX:-UseBisasedLocking = false 来设置
        **/
        Thread.sleep(5000); //为了开启偏向锁
        User user1 = new User();
        System.out.println("启用偏向锁(101): "+ ClassLayout.parseInstance(user1).toPrintable());

        for (int i = 0; i <2 ; i++) {
            synchronized (user1){
                System.out.println("偏向锁(101)(带线程id): "+ ClassLayout.parseInstance(user1).toPrintable());
            }
            System.out.println("偏向锁释放(101)(带线程id): "+ ClassLayout.parseInstance(user1).toPrintable());
        }
        new Thread( ()-> {
            synchronized (user1) {
                System.out.println("轻量级锁(00) : " + ClassLayout.parseInstance(user1).toPrintable());
                System.out.println("睡眠3秒钟===============");
                try {
                    Thread.sleep(3000);//目的是让 后面启动的线程过来 竞争锁  让轻量级锁变为重量级锁
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("轻量-->重量(10) : " + ClassLayout.parseInstance(user1).toPrintable());
            }
        }
        ).start();

        Thread.sleep(1000);//上面锁未释放，升级为重量级锁
        new Thread(()->{
            synchronized (user1){
                System.out.println("重量(10) : "+ ClassLayout.parseInstance(user1).toPrintable());
            }
        }).start();

    }
}

控制台打印情况

无状态(001): lock.User object internals:
 OFFSET  SIZE                TYPE DESCRIPTION                               VALUE
      0     4                     (object header)                           01 00 00 00 (00000001 00000000 00000000 00000000) (1)
      4     4                     (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4                     (object header)                           43 c1 00 20 (01000011 11000001 00000000 00100000) (536920387)
     12     4   java.lang.Integer User.id                                   null
     16     4    java.lang.String User.name                                 null
     20     4                     (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

启用偏向锁(101): lock.User object internals:
 OFFSET  SIZE                TYPE DESCRIPTION                               VALUE
      0     4                     (object header)                           05 00 00 00 (00000101 00000000 00000000 00000000) (5)
      4     4                     (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4                     (object header)                           43 c1 00 20 (01000011 11000001 00000000 00100000) (536920387)
     12     4   java.lang.Integer User.id                                   null
     16     4    java.lang.String User.name                                 null
     20     4                     (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

偏向锁(101)(带线程id): lock.User object internals:
 OFFSET  SIZE                TYPE DESCRIPTION                               VALUE
      0     4                     (object header)                           05 30 90 02 (00000101 00110000 10010000 00000010) (43003909)
      4     4                     (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4                     (object header)                           43 c1 00 20 (01000011 11000001 00000000 00100000) (536920387)
     12     4   java.lang.Integer User.id                                   null
     16     4    java.lang.String User.name                                 null
     20     4                     (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

偏向锁释放(101)(带线程id): lock.User object internals:
 OFFSET  SIZE                TYPE DESCRIPTION                               VALUE
      0     4                     (object header)                           05 30 90 02 (00000101 00110000 10010000 00000010) (43003909)
      4     4                     (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4                     (object header)                           43 c1 00 20 (01000011 11000001 00000000 00100000) (536920387)
     12     4   java.lang.Integer User.id                                   null
     16     4    java.lang.String User.name                                 null
     20     4                     (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

偏向锁(101)(带线程id): lock.User object internals:
 OFFSET  SIZE                TYPE DESCRIPTION                               VALUE
      0     4                     (object header)                           05 30 90 02 (00000101 00110000 10010000 00000010) (43003909)
      4     4                     (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4                     (object header)                           43 c1 00 20 (01000011 11000001 00000000 00100000) (536920387)
     12     4   java.lang.Integer User.id                                   null
     16     4    java.lang.String User.name                                 null
     20     4                     (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

偏向锁释放(101)(带线程id): lock.User object internals:
 OFFSET  SIZE                TYPE DESCRIPTION                               VALUE
      0     4                     (object header)                           05 30 90 02 (00000101 00110000 10010000 00000010) (43003909)
      4     4                     (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4                     (object header)                           43 c1 00 20 (01000011 11000001 00000000 00100000) (536920387)
     12     4   java.lang.Integer User.id                                   null
     16     4    java.lang.String User.name                                 null
     20     4                     (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

轻量级锁(00) : lock.User object internals:
 OFFSET  SIZE                TYPE DESCRIPTION                               VALUE
      0     4                     (object header)                           88 f2 f5 1a (10001000 11110010 11110101 00011010) (452326024)
      4     4                     (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4                     (object header)                           43 c1 00 20 (01000011 11000001 00000000 00100000) (536920387)
     12     4   java.lang.Integer User.id                                   null
     16     4    java.lang.String User.name                                 null
     20     4                     (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

睡眠3秒钟===============
轻量-->重量(10) : lock.User object internals:
 OFFSET  SIZE                TYPE DESCRIPTION                               VALUE
      0     4                     (object header)                           9a f5 90 17 (10011010 11110101 10010000 00010111) (395376026)
      4     4                     (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4                     (object header)                           43 c1 00 20 (01000011 11000001 00000000 00100000) (536920387)
     12     4   java.lang.Integer User.id                                   null
     16     4    java.lang.String User.name                                 null
     20     4                     (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

重量(10) : lock.User object internals:
 OFFSET  SIZE                TYPE DESCRIPTION                               VALUE
      0     4                     (object header)                           9a f5 90 17 (10011010 11110101 10010000 00010111) (395376026)
      4     4                     (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4                     (object header)                           43 c1 00 20 (01000011 11000001 00000000 00100000) (536920387)
     12     4   java.lang.Integer User.id                                   null
     16     4    java.lang.String User.name                                 null
     20     4                     (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total


Process finished with exit code 0

说明

beichenL
关注
专栏目录
《Java并发编程实战》学习笔记
admin1_的博客
10-27 615
什么是并发编程？ 跳出来看全局就是3部分：分工、协作、互斥 钻进去看本质：技术的本质就是背后的理论模型 并发理论基础 并发编程产生bug的原因 可见性：cpu缓存导致共享变量在多核cpu的情况下，不可见，所以计算会出错 原子性：高级语言中的一个操作可能是操作系统中多个操作，如count + =1 ，其实对应操作系统3步操作「1、count从内存加载到cpu寄存器；2、寄存器执行+1操作；3、将结果写回内存（缓存机制可能回写回cpu缓存而不是内存）」 有序性：编译优化后，代码执行顺序可能发生变化 Ja
synchronized的四种用法
行走江湖的少侠哥
06-06 6万+
一  修饰一个方法 Synchronized修饰一个方法很简单，就是在方法的前面加synchronized，synchronized修饰方法和修饰一个代码块类似，只是作用范围不一样，修饰代码块是大括号括起来的范围，而修饰方法范围是整个函数。 例如： 方法一 public synchronized void method() { // todo }方法二 public v
锁升级过程
qq_37495340的博客
05-07 328
synchronized 作用在方法上，锁对象是当前实例 synchronized 作用在静态方法上，锁对象是当前类对象 synchronized 作用在代码快上，锁对象需要提供锁的对象 java6 版本以后对 synchronized 做了优化，引入多种锁状态： ...
线程同步——synchoronized
chengyiwo8128的博客
12-14 164
多线程中多个线程共享数据，多个线程对于共享的数据继续操作时，如果我们很好的控制就会发生错误。接下来看一个多个线程同时操作同一个数据的例子。 publicclassThreadCount{ publicstaticvoidmain(String[]args){ ...
synchoronized\Lock锁源码分析
hotpots--火锅技术栈
11-30 206
owner 当前锁线程 waitset 等待队列(o.wait()) cxq EntryList 同步队列 等待队列 AQS加锁流程
Synchornized使用及原理
qianwenhong
06-04 3184
同步，可见，synchornized，volatile
Jdk源码阅读 ：synchronized 底层实现
sinat_37255539的博客
02-07 325
synchoronized 底层实现 monitorenter & monitorexit public class SychoronizeTest { private static final Object lock = new Object(); public static void main(String[] args) { synchronized (lock){ int i=1; } } } public
高效并发：Synchornized的锁优化详解
qq_53578500的博客
07-30 612
高效并发是从JDK 5升级到JDK 6后一项重要的改进项，HotSpot虚拟机开发团队在这个版本上花费了大量的资源去实现各种锁优化技术，如适应性自旋（Adaptive Spinning）、锁消除（LockElimination）、锁膨胀（Lock Coarsening）、轻量级锁（Lightweight Locking）、偏向锁（BiasedLocking）等，这些技术都是为了在线程之间更高效地共享数据及解决竞争问题，从而提高程的执行效率......
synchoronized 为什么不能锁 int 或者 long 类型
心比天高，仗剑走天涯，保持热爱，奔赴向梦想！
02-06 775
不能用String常量因为字符串常量是在内存中同一个地方。如果两个线程锁一个，可能导致死锁。一个线程多次可能导致重入。也不能用Integer，Long等基础类型。因为当锁定int或者long时， jvm就会调用Interger.valueOf()生成一个新的对象，所以锁不会失效看源码可知，java会把-128到127所对应的包装类都给缓存起来，分别存入了IntegerCache和LongCache而当锁的值大于127之后，就会新建一个对象，在堆上产生，这时，锁就会失效。
Java多线程 - 锁与死锁
qq_57294248的博客
03-21 218
上一次，我们讲到了一些线程安全的问题，以及导致线程不安全的原因，这一次，我们来讲解，如何来线程变得更安全。
Lock、Synchoronized和ReentrantLock的使用
11-11
Lock、Synchoronized和ReentrantLock的使用
synchronized三种使用方式
man_8211的专栏
06-08 3817
前言 在多线程并发编程中Synchronized一直是元老级角色，大家都知道synchronized是重量级锁，但是随着Java SE1.6对Synchronized进行了各种优化之后，有些情况下它并不那么重了，与lock相比性能相差并不是很大，还是比较建议同步的时候优先使用synchronized。 三种使用方式 修饰实例方法，作用于当前实例加锁，进入同步代码前要获得当前实例的锁 修饰静
Synchronized 关键字原理
钱立清的博客
10-13 6万+
众所周知synchronized关键字是解决并发问题常用解决方案，有以下四种使用方式： 修饰代码块，即同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象。 修饰方法，即同步方法，其作用的范围是整个方法，作用的对象是调...
【Java并发编程之深入理解】Synchronized的使用
热门推荐
青苔小榭
09-08 23万+
1.为什么要使用synchronized 在并发编程中存在线程安全问题，主要原因有：1.存在共享数据 2.多线程共同操作共享数据。关键字synchronized可以保证在同一时刻，只有一个线程可以执行某个方法或某个代码块，同时synchronized可以保证一个线程的变化可见（可见性），即可以代替volatile。 2.实现原理 synchronized可以保证方法或者代码块在运行时，同...
java synchronized详解
xiechengfa的技术笔记
04-22 142
http://www.cnblogs.com/GnagWang/archive/2011/02/27/1966606.html
synchronized关键字（同步锁）详细解析
IBLiplus的博客
10-08 1890
这里大部分的解释都在代码中。 demo1 package synchornizeds; public class Demo1 { private int count; private Object o = new Object(); public void m() { synchronized (o) { //任何线程执行一下代码都要申请o对应的锁。此处的o是堆内存中new...
synchronized锁升级的底层实现
胜天半子
03-01 461
一、synchronized可用在如下场景 1、修饰实例的方法 用于锁定当前对象this。 public synchronzied void test() {...} 2、修饰静态方法 用于锁定当前类 public static synchronized void test() {...} 3、修饰代码块 public void test() { // 对当前对象this加锁 synchr...
Spring Boot 学习和使用
最新发布
cesske的博客
09-24 1070
Spring Boot是一款开源的Java Web应用框架，旨在简化Spring应用的初始搭建以及开发过程。Spring Boot通过整合Spring技术栈中的诸多关键组件，为开发者提供了一种快速、简便的Spring应用开发方式。它遵循“约定优于配置”的原则，通过自动配置、起步依赖和内置的Servlet容器，极大地简化了传统Spring应用的配置和部署过程。Spring Boot通过其自动化配置、起步依赖、内嵌服务器等特性，极大地简化了Spring应用的开发和部署过程。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值