Java并发编程- Synchronized原理

最新推荐文章于 2024-09-21 02:37:48 发布
最新推荐文章于 2024-09-21 02:37:48 发布
阅读量494 收藏 5
点赞数
CC 4.0 BY-SA版权
分类专栏： Java 文章标签： Java并发编程- Synchronized原理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/wflovejava/article/details/96857849
本文详细解析了Java中的Synchronized关键字，包括其在不同JDK版本中的实现变化，从无锁到偏向锁、轻量级锁再到重量级锁的过程，并介绍了锁的状态及其实现原理。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Java并发编程- Synchronized原理

在jdk.1.6之前是重量级锁，jdk1.6之后对synchronzied的关键字的优化之后，引入了偏向锁，轻量级锁。

1.先来看synchronzied使用的基础：

static  A a = new A();

//普通同步方法
public synchronized void test(){
    System.out.println("锁的是当前对象实例");
}
//静态同步方法
public static synchronized void test1(){
    System.out.println("锁的是当前类的Class对象");
}
//同步方法块
public   void test2(){
    synchronized (a){
        System.out.println("锁的是括号里配置的对象");
    }
}

2. synchronzied使用的锁在哪呢？存在对象头里，

整个对象存储情况,运行代码查看结果分析:

public class A {

    private boolean b;
}
public class Test {
    static  A a = new A();
    public static void main(String[] args) {
        System.out.println(VM.current().details());
        System.out.println(ClassLayout.parseInstance(a).toPrintable());
    }
}

运行结果分析：

分析：对象一共16B，其中12B是对象头，1B是对象实例数据，3B是字节对齐

对象的长度

长度内容说明
12B对象头存储信息，hashcode，年代信息等。
1B对象实例数据存储对象的实例数据
3B字节对齐 

对象头12B存储哪些内容呢？64位的VM

可以从openjdk.java.net/groups/hotspot/docs/HotSpotGlossary.html 官网上看到,存储的内容是mark word 和klass word

java对象头的长度

长度内容说明
8Bmark word存储着锁的信息，hashcode，gc信息等等
4Bklass word 指向对象的元数据

java对象头的结构

无锁的对象头如下：

第一个字节的前8位存储着，分代年龄4个bit，锁的标识2个bit，是否偏向1个bit，和没有使用的1个bit。

其他的7个字节存储着hashcode信息。

锁状态56bit4bit1bit是否偏向锁2bit锁的标识
无锁对象hashcode对象分代年龄001

我们知道对象的状态一共五种状态：无锁，偏向锁，轻量级锁，重量级锁，gc标记的锁。

3. 偏向锁

概念：同一个线程多次获取同一把锁。（只有一个线程调用同步块）

代码：

public class Test {
    static  A a ;
    public static void main(String[] args) {
        Thread.sleep(5000);//jvm 延时启动偏向锁，是默认4s之后开启，可以设置关闭延时。因为启动的时候就使用偏向锁，比较消耗性能，升级锁比较费时间。

        System.out.println(VM.current().details());
        a = new A();
        System.out.println(ClassLayout.parseInstance(a).toPrintable());
        syn();
            System.out.println(ClassLayout.parseInstance(a).toPrintable());
    }
    public static  synchronized  void syn(){
        System.out.println("演示偏向锁-----------");
    }
}

输出结果：

演示偏向锁-----------

 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)                           80 22 01 f8 (10000000 00100010 00000001 11111000) (-134143360)
     12     1   boolean A.b                                       false
     13     3           (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 3 bytes external = 3 bytes total

分析结果：程序只有一个线程main调用syn方法，因此是偏向锁，也可以使用-XX:+UseBiasedLocking -XX:BiasedLockingStartupDelay=0禁用延时。-XX:+TraceClassLoading （跟踪加载）

4. 轻量级锁：线程交替运行，无竞争。

public class Test {
    static  A a ;
    public static void main(String[] args) throws InterruptedException {
      //  System.out.println(VM.current().details());
        a = new A();
        System.out.println(ClassLayout.parseInstance(a).toPrintable());
        syn();
        System.out.println(ClassLayout.parseInstance(a).toPrintable());

    }
    public static    void syn(){
        synchronized (a){
            out.println("lock ing");
            System.out.println(ClassLayout.parseInstance(a).toPrintable());
        }
    }
}

运行结果：
 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 f8 (01000011 11000001 00000000 11111000) (-134168253)
     12     1   boolean A.b                                       false
     13     3           (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 3 bytes external = 3 bytes total

lock ing
com.luban.wf.A object internals:
 OFFSET  SIZE      TYPE DESCRIPTION                               VALUE
      0     4           (object header)                           a0 f5 e7 02 (10100000 11110101 11100111 00000010) (48756128)
      4     4           (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4           (object header)                           43 c1 00 f8 (01000011 11000001 00000000 11111000) (-134168253)
     12     1   boolean A.b                                       false
     13     3           (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 3 bytes external = 3 bytes total

com.luban.wf.A 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 f8 (01000011 11000001 00000000 11111000) (-134168253)
     12     1   boolean A.b                                       false
     13     3           (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 3 bytes external = 3 bytes total


Process finished with exit code 0
 

分析结果：lock ing 输出的10100000 轻量级锁。

 

5. 重量级锁：

public class Test2 {
    static  A a ;

    public static void main(String[] args) throws InterruptedException {
        a = new A();
        System.out.println("before lock");
        out.println(ClassLayout.parseInstance(a).toPrintable());//轻量锁

        Thread t1 = new Thread(new Runnable() {
            public void run() {
                synchronized (a){

                    synchronized (a){
                        System.out.println("before wait");
                        out.println(ClassLayout.parseInstance(a).toPrintable());//轻量锁
                        try {
                            a.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println("after wait");
                        out.println(ClassLayout.parseInstance(a).toPrintable());//重量级锁
                    }
                }
            }
        });

        t1.start();

        Thread.sleep(5000);
        synchronized (a){
            a.notifyAll();//唤醒线程t1
        }

    }


}

运行结果：


before lock
 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 f8 (01000011 11000001 00000000 11111000) (-134168253)
     12     1   boolean A.b                                       false
     13     3           (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 3 bytes external = 3 bytes total

before wait
 OFFSET  SIZE      TYPE DESCRIPTION                               VALUE
      0     4           (object header)                           a0 f2 7b 1c (10100000 11110010 01111011 00011100) (477885088)
      4     4           (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4           (object header)                           43 c1 00 f8 (01000011 11000001 00000000 11111000) (-134168253)
     12     1   boolean A.b                                       false
     13     3           (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 3 bytes external = 3 bytes total

after wait
 OFFSET  SIZE      TYPE DESCRIPTION                               VALUE
      0     4           (object header)                           da d7 e2 19 (11011010 11010111 11100010 00011001) (434296794)
      4     4           (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4           (object header)                           43 c1 00 f8 (01000011 11000001 00000000 11111000) (-134168253)
     12     1   boolean A.b                                       false
     13     3           (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 3 bytes external = 3 bytes total


Process finished with exit code 0
 

运行结果分析：after wait  的为11011010 重量级锁

 

 

 

6. 偏向锁的批量撤销:

 

 

 

7. 轻量级锁的膨胀过程：

 

 

 

 

 

 

 

 

8.总结：

锁有哪几种：公平锁和非公平锁（线程获取锁的机会不是均匀的）

工作当中怎样选择锁：

Synchronized 是有sun公司实现的 jvm内部调用操作系统实现的

1.是个非公平锁，

2.使用简单，

3.经过优化了，偏向锁，轻量级锁，重量级锁

lock jdk实现的：

1.是个公平锁，

2.需要手动释放锁

3.如果要实现高级功能，可以使用

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Java获取对象的内存地址
与望
08-02 6233
前言 我们知道在Java中对于synchronized对于同步方法锁的是当前的实例对象。 例如以下这段代码： import java.util.concurrent.TimeUnit; public class Test { public static void main(String[] args) { Test test = new Test(); test.helper(); } public synchronized void helper
Java并发编程系列- synchronized
06-16
本篇文章将深入探讨`synchronized`的使用及其在Java并发编程中的作用。 首先，`synchronized`关键字的主要功能是实现线程同步，确保同一时间只有一个线程可以执行特定的代码段。这在处理共享数据时尤为重要，因为它...
java查看对象真实地址和哈希值的工具类
进击的豌豆的博客
09-01 2495
HotSpot JVM 中有不同的压缩引用模式。因此，我们不应该根据该地址执行一些本机内存操作，因为它可能会导致奇怪的内存损坏。hashCode()方法是所有 Java 对象的常用方法之一。有一种常见的误解，认为 JVM 中对象的内存地址是作为其默认 toString 实现的一部分表示的，例如。此外，大多数 JVM 实现中的内存地址会随着 GC 不时移动对象而发生变化。可以查看对象未被重写的hashcode值；在JVM中查找特定对象的内存地址；也就是说，许多人认为这里的。是该特定对象的内存地址。...
深入理解Java对象结构
最新发布
weixin_36968890的博客
09-21 362
一、Java对象结构 实例化一个Java对象之后，该对象在内存中的结构是怎么样的？Java对象（Object实例）结构包括三部分：对象头、对象体和对齐字节，具体下图所示 1、Java对象的三部分 （1）对象头 对象头包括三个字段，第一个字段叫作Mark Word（标记字），用于存储自身运行时的数据，例如GC标志位、哈希码、锁状态等信息。 第二个字段叫作Class Pointer（类对象指针），...
多线程四 并发中锁的原理
用针戳左手中指指头的博客
04-06 569
先来引入锁的概念: 偏向锁：当前只有一个锁，无线程竞争的情况下，尽量减少不必要的轻量锁的执行路径。 偏向锁就是在运行过程中，对象的锁偏向某个线程，即在开启偏向锁的情况下，某个线程获得锁，当该线程下次想要获得锁时，不需要再获取锁（忽略synchronized关键字），直接执行代码 轻量锁：存在锁之间的竞争，但竞争的会很小， 重量锁：存在资源竞争 openjdk对对象头的注释 // 6...
Java对象大小与内存布局
CaptHua的博客
06-10 2073
Java对象大小，内存布局
Java并发编程---synchronized关键字
10-30
Java并发编程---synchronized关键
深入理解高并发编程-核心技术原理
03-14
总的来说，这本书全面覆盖了高并发编程中的关键知识点，包括多线程原理、线程池实现、并发控制、分布式系统架构以及面试技巧，适合有志于提升并发编程能力的后端开发者阅读，尤其是对分布式锁和Java并发编程感兴趣的...
Java并发编程-并发容器1
08-03
总结起来，Java并发编程中的并发容器，尤其是ConcurrentHashMap，通过巧妙的设计和高效的并发机制，如 CAS 操作和synchronized的使用，实现了线程安全且高性能的键值存储。在面临高并发场景时，ConcurrentHashMap...
java并发编程实战源码-jcip-examples:java并发编程实战
05-25
《Java并发编程实战》是Java并发编程领域的一本经典之作，由Brian Goetz等作者撰写。这本书深入浅出地介绍了Java并发编程的各种概念和技术，帮助开发者理解和掌握如何在多线程环境中编写高效、安全的代码。jcip-...
学习小记 -- Java对象内存布局之理解
weixin_42029860的博客
06-08 471
根据Java虚拟机的规范：Java对象分为对象头(Object Header), 实例数据(instance data)，对齐填充(padding)。如图：
JDK1.6对synchronized锁的优化
自律使我自由
07-03 2279
在JDK1.6之前synchronized关键属于一种重量级的锁，性能能略显不足，从JDK1.6开始对synchronized做了一些优化，感觉主要就是针对到底要不要加锁，加什么锁做了一些判断，下面一起来看一下吧。 1、锁消除 最大程度的优化就是没有锁，那么如何判断能不能消除synchronized呢？在编译期间有一种优化叫做逃逸分析。 如果证明一个对象不会逃逸到方法外或者线程外，则可针对此变量进行优化，JVM判断对象是否逃逸的依据有： 1、对象被赋值给堆中对象的字段和类的静态变量。 2、对象被传进了不确定
面经手册 · 第15篇《码农会锁，synchronized 解毒，剖析源码深度分析！》
bugstack虫洞栈
10-29 2236
作者：小傅哥 博客：https://bugstack.cn 沉淀、分享、成长，让自己和他人都能有所收获！???? 一、前言 感觉什么都不会，从哪开始呀！ 这是最近我总能被问到的问题，也确实是。一个初入编程职场的新人，或是一个想重新努力学习的老司机，这也不会，那也不会，总会犯愁从哪开始。 讲道理，毕竟 Java 涉及的知识太多了，要学应该是学会学习的能力，而不是去背题、背答案，拾人牙慧是不会有太多收益的。 学习的过程要找对方法，遇到问题时最好能自己想想，你有哪些方式学会这些知识。是不感觉即使让你去百度搜，
JDK之JVM中Java对象的头部占多少byte
weixin_34344403的博客
06-30 1589
2019独角兽企业重金招聘Python工程师标准>>> ...
获取Java VM中当前运行的所有线程
weixin_30411997的博客
08-10 195
/** * 获取Java VM中当前运行的所有线程 * @return */ public static Thread[] findAllThreads() { ThreadGroup group = Thread.currentThread().getThreadGroup(); Threa...
java对象头分析
diligence-zpf
07-17 2778
一:对象头介绍 hotSpot虚拟机中,对象在内存中的存储布局可以分为三块区域：对象头(header),实例数据(Insrance Data)和对齐填充(Padding). HotSpot虚拟机的对象头(Object Header)包括两部分信息,第一部分用于存储对象自身的运行时数据，如：哈希码(HashCode),GC分带年龄，锁状态标志，线程持有的锁，偏向线程ID，偏向时间戳等等，这部分数据的...
java应用之VM工具类
weixin_43495941的博客
11-20 461
public class VMUtils { private VMUtils() { } private static final Logger logger = LoggerFactory.getLogger(VMUtils.class); /** * 当前进程ID */ // private static fina...
深入浅出-JVM中堆和栈
weixin_42304845的博客
06-30 382
这里写目录标题1、JVM中的堆栈（1.8）1.1 JVM内存模型1.2 JVM运行数据区内存模型1.1 堆栈的比较三级目录2、new对象的时候发生了什么2.1 类加载过程（第一次使用该类）2.1.1 加载2.1.2 验证2.1.3 准备2.1.4 解析2.1.5 初始化（先父后子）2.2 创建对象2.2.1 在兑取分配对象需要的内存2.2.2 对所有实例变量赋默认值2.2.3 执行实例初始化代码2.2.4 将对象的内存地址赋值给引用变量3、 值引用和对象应用的区别4、Code Demo5、思考 1、JVM中
【转载】Java中的锁机制 synchronized & 偏向锁 & 轻量级锁 & 重量级锁 & 各自优缺点及场景 & AtomicReference...
weixin_34326558的博客
10-24 426
参考文章： http://blog.csdn.net/chen77716/article/details/6618779 目前在Java中存在两种锁机制：synchronized和Lock，Lock接口及其实现类是JDK5增加的内容，其作者是大名鼎鼎的并发专家Doug Lea。本文并不比较synchronized与Lock孰优孰劣，只是介绍二者的实现原理。 数据同步需要依赖锁，那锁的同步又依赖谁？...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值