脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → Java synchronized

深入讲解Java synchronized的核心原理

 更新时间：2023年07月18日 11:42:16   作者：我是小趴菜  
这篇文章主要为大家详细介绍了Java中synchronized的核心原理以及简单的用法，文中的示例代码讲解详细，感兴趣的小伙伴可以跟随小编一起学习一下

前言

在此之前先有几个面试题，看大家能答对几题

1.1: 标准访问ab二个线程，是先打印t1还是t2

public class SyncUnit {
    public synchronized void t1() {
        System.out.println("t1");
    }
    public synchronized void t2() {
        System.out.println("t2");
    }
    public static void main(String[] args) throws Exception{
        SyncUnit syncUnit = new SyncUnit();
        new Thread(() -> {
            syncUnit.t1();
        }).start();
        Thread.sleep(100);
        new Thread(() -> {
           syncUnit.t2();
        }).start();
    }
}

1.2: t1方法暂停3秒钟，是先打印t1还是t2

public class SyncUnit {
    public synchronized void t1(){
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("t1");
    }
    public synchronized void t2() {
        System.out.println("t2");
    }
    public static void main(String[] args) throws Exception{
        SyncUnit syncUnit = new SyncUnit();
        new Thread(() -> {
            syncUnit.t1();
        }).start();
        Thread.sleep(100);
        new Thread(() -> {
           syncUnit.t2();
        }).start();
    }

1.3: 新增一个普通方法hello(),是先打印t1还是hello

public class SyncUnit {
    public synchronized void t1(){
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("t1");
    }
    public synchronized void t2() {
        System.out.println("t2");
    }
    public void hello() {
        System.out.println("hello");
    }
    public static void main(String[] args) throws Exception{
        SyncUnit syncUnit = new SyncUnit();
        new Thread(() -> {
            syncUnit.t1();
        }).start();
        Thread.sleep(100);
        new Thread(() -> {
           syncUnit.hello();
        }).start();
    }
}

1.4: 现在有二个SyncUnit对象，是先打印t1还是t2

public class SyncUnit {
    public synchronized void t1(){
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("t1");
    }
    public synchronized void t2() {
        System.out.println("t2");
    }
    public static void main(String[] args) throws Exception{
        SyncUnit syncUnit = new SyncUnit();
        SyncUnit syncUnit1 = new SyncUnit();
        new Thread(() -> {
            syncUnit.t1();
        }).start();
        Thread.sleep(100);
        new Thread(() -> {
           syncUnit1.t2();
        }).start();
    }

1.5: 二个静态同步方法，一个SuncUnit对象，是先打印t1还是t2

public class SyncUnit {
    public static synchronized void t1(){
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("t1");
    }
    public static synchronized void t2() {
        System.out.println("t2");
    }
    public static void main(String[] args) throws Exception{
        SyncUnit syncUnit = new SyncUnit();
        new Thread(() -> {
            syncUnit.t1();
        }).start();
        Thread.sleep(100);
        new Thread(() -> {
           syncUnit.t2();
        }).start();
    }
}

1.6: 二个静态同步方法，二个SyncUnit对象，是先打印t1还是t2

public class SyncUnit {
    public static synchronized void t1(){
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("t1");
    }
    public static synchronized void t2() {
        System.out.println("t2");
    }
    public static void main(String[] args) throws Exception{
        SyncUnit syncUnit = new SyncUnit();
        SyncUnit syncUnit1 = new SyncUnit();
        new Thread(() -> {
            syncUnit.t1();
        }).start();
        Thread.sleep(100);
        new Thread(() -> {
           syncUnit1.t2();
        }).start();
    }
}

1.7: 一个静态同步方法，普通同步方法，一个SyncUnit对象，是先打印t1还是t2

public class SyncUnit {
    public static synchronized void t1(){
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("t1");
    }
    public synchronized void t2() {
        System.out.println("t2");
    }
    public static void main(String[] args) throws Exception{
        SyncUnit syncUnit = new SyncUnit();
        new Thread(() -> {
            syncUnit.t1();
        }).start();
        Thread.sleep(100);
        new Thread(() -> {
           syncUnit.t2();
        }).start();
    }
}

1.8 一个静态同步方法，普通同步方法，二个SyncUnit对象，是先打印t1还是t2

public class SyncUnit {
    public static synchronized void t1(){
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("t1");
    }
    public synchronized void t2() {
        System.out.println("t2");
    }
    public static void main(String[] args) throws Exception{
        SyncUnit syncUnit = new SyncUnit();
        SyncUnit syncUnit1 = new SyncUnit();
        new Thread(() -> {
            syncUnit.t1();
        }).start();
        Thread.sleep(100);
        new Thread(() -> {
           syncUnit1.t2();
        }).start();
    }
}

synchronized用法

synchronized是java提供的一种解决多线程并发安全的一种内置锁，尽管在jdk1.5之前还被大家吐槽性能问题，但是在1.5之后对synchronized不断的优化，在单机程序中，当设计多线程并发问题时，我们完全可以使用synchronized解决

同步实例方法

 public synchronized void method() {
      //方法逻辑
 }

当synchronized修饰的是一个普通方法的时候，相当于对this对象加锁，一个实例是可以创建多个对象的，所以可以拥有多把锁，就比如下面这个例子，我们创建了二个对象，那就是二把不同的锁，所以在调用t1()的时候，t2()方法由于是不同的锁，所以会直接执行方法

public class SyncUnit {
        public synchronized void t1(){
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("t1");
        }
        public synchronized void t2() {
            System.out.println("t2");
        }
        public static void main(String[] args) throws Exception{
            SyncUnit syncUnit = new SyncUnit();
            SyncUnit syncUnit1 = new SyncUnit();
            new Thread(() -> {
                syncUnit.t1();
            }).start();
            Thread.sleep(100);
            new Thread(() -> {
               syncUnit1.t2();
            }).start();
        }
    }

同步静态方法

 public static synchronized void method() {
     //方法逻辑
 }

当synchronized修饰的是一个静态方法的时候，相当于对当前实例加锁，一个类只有一个实例，所以无论你创建多少个对象，都只有一把锁，比如下面这个例子，虽然创建了二个不同的对象，但是实际只有一把锁，所以是先打印t1(),然后在打印t2(),因为t2()要等待t1()把锁释放掉之后才能获取到锁

   public class SyncUnit {
            public static synchronized void t1(){
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("t1");
            }
            public static synchronized void t2() {
                System.out.println("t2");
            }
            public static void main(String[] args) throws Exception{
                SyncUnit syncUnit = new SyncUnit();
                SyncUnit syncUnit1 = new SyncUnit();
                new Thread(() -> {
                    syncUnit.t1();
                }).start();
                Thread.sleep(100);
                new Thread(() -> {
                   syncUnit1.t2();
                }).start();
            }
       }

代码块

   public Object object = new Object();
   public void method() {
      synchronized(object) {
         //方法逻辑
      }
   }

这时候的object是一个对象，就相当于在普通方法上添加synchronized，如果是不同的对象，那么就是不同的锁

      public void method() {
          synchronized(Test.class) {
             //方法逻辑
          }
       }

这时候就相当于在静态方法上添加synchronized，也就是对当前实例加锁，一个类只有一个实例

synchronized核心原理

synchornized是基于JVM中的Monitor锁实现的，Java1.5版本之前的synchornized锁性能较低，但是从1.6版本之后，对synchornized进行了大量的优化，引入了锁粗化，锁消除，偏向锁，轻量级锁，适应性自旋等技术来提升synchornized的性能

1.synchornized修饰的是方法

当synchornized修饰的是方法的时候，当前方法会比普通方法多一个ACC_SYNCHRONIZED的标识符

当JVM执行程序的时候，会判断这个方法是否有ACC_SYNCHRONIZED这个标识符，如果有，则当前线程优先获取Monitor对象，同一个时刻只能有一个线程获取到，在当前线程释放Monitor对象之前，其它线程无法获取到同一个Monitor对象，从而保证了同一时刻只能有一个线程进入到被synchornized修饰的方法

2.synchornized修饰的是代码块

当synchornized修饰的是代码块的时候，synchornized关键字会被编译成monitorenter和monitorexit，使得同一时刻只能有一个线程进入到同步代码块中，但是这里为什么会有二个monitorexit，是因为程序正常退出的时候需要释放锁，在程序异常的时候也要释放锁，所以会对应二个

无论synchornized修饰的是方法还是代码块，底层都是通过JVM调用操作系统的Mutes锁实现的，当线程被阻塞时会被挂起，等待CPU重新调度，这会导致线程在操作系统的用户态和内核态之间切换，影响性能

Monitor锁原理

synchornized低成是基于Monitor锁来实现的，而Monitor锁是基于操作系统的Mutex锁实现的，Mutex锁是操作系统级别的重量级锁，所以性能较低

在Java中，创建的任何一个对象在JVM中都会关联一个Monitor对象，所以说任何一个对象都可以成为锁。

在HotSpot JVM中，Monitor是由ObjectMoitor实现的，在ObjectMonitor对象的数据结构中，有几个重要的属性

  • _WaitSet：是一个集合，当线程获到锁之后，但是还没有完成业务逻辑，也还没释放锁，这时候调用了Object类的wait()方法，这时候这个线程就会进入_WaitSet这个集合中等待被唤醒，也就是执行nitify()或者notifyAll()方法唤醒
  • _EntryList：是一个集合，当有多个线程来获取锁，这时候只有一个线程能成功拿到锁，剩下那些没有拿到锁的线程就会进入_EntryList集合中，等待下次抢锁
  • _Owner：当一个线程获取到锁之后，就会将该值设置成当前线程，释放锁之后，这个值就会重新被设置成null
  • _count：当一个线程获取到锁之后，_count的值就会+1，释放锁之后就会-1，只有当减到0之后，才算真正的释放掉锁了，其它线程才能来获取这把锁，synchornized可重入锁也是基于这个值来实现的

所以当多个线程同时访问被synchornized修饰的方法或者代码块时候，synchornized加锁和释放锁的底层实现流程大致为：

  • 1:进入_EntryList集合，当某个线程获取到锁之后，这个线程就会进入_Owner区域，就会将Monitor对象的_owner变量复制为当前线程。并把_count值+1
  • 2:当线程调用wait()方法时，当前线程会释放掉持有的Monitor对象，并把_owner赋值成null，_count的值-1，同时这个线程就会进入_WaitSet集合等到被唤醒
  • 3:如果获取到锁的线程执行完毕，也会释放Monitor锁。，_owner被置为null,_count被置为0

偏向锁

虽然在程序的方法中或代码块中添加了synchornized，但是在大部分的情况下，不会存在多线程竞争这种情况，并且会出现同一个线程多次获取同一把锁的现象，为了提升这种情况下程序的性能，引入了偏向锁

轻量级锁

当多线程竞争锁不激烈时，可以通过CAS机制竞争锁，这就是轻量级锁，引入轻量级锁的目的是在多线程竞争锁不激烈时，避免由于使用操作系统层面的Mutex重量级锁导致性能低下

重量级锁

重量级锁主要是基于操作系统的Mutex锁实现，重量级锁的执行效率较低，处于重量级锁时被阻塞的线程不会消耗CPU资源

锁升级过程

多个线程在争抢synchornized锁时，在某些情况下，会由无锁状态一步步升级为最终的重量级锁，整个升级过程大致包括如下几个步骤

  • 1：线程在竞争synchornized时，JVM首先会检查锁对象的Mark Word中偏向锁的标记位是否为1，锁标记位是否为01，如果二个条件都满足，则当前锁处于偏向锁状态
  • 2：争抢synchornized锁线程检查锁对象的Mark Work中存储的线程ID是否是自己的，如果是自己的线程ID，则表示处于偏向锁状态，当前线程可以直接进入方法或者代码块
  • 3：如果锁对象的Mark Word的线程ID不是自己的线程ID，那么就会通过CAS方式来竞争锁资源，如果获取到锁资源了，就将Mark Word中存储的线程ID修改成自己的线程ID，将偏向锁的标记设置成1，锁标记位置设置成01，当前锁处于偏向锁状态
  • 4：如果当前线程通过CAS没有获取到锁资源，则说明有其它线程也在争抢资源，此时会撤销偏向锁，升级为轻量级锁，并将Mark Word的锁标记为都清空
  • 5：当前线程与其它线程还是会通过CAS方式来竞争资源，如果某个线程成功获取到资源，就会将锁对象的Mark Word中的锁标志位设置成00，此时进入轻量级锁状态
  • 6：竞争失败的线程还是会通过CAS方式来获取锁，但是当CAS达到一定的次数以后，就会升级为重量级锁了

以上就是深入讲解Java synchronized的核心原理的详细内容，更多关于Java synchronized的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:

相关文章

  • SpringBoot项目实现Excel上传功能的示例代码

    SpringBoot项目实现Excel上传功能的示例代码

    这篇文章主要为大家详细介绍了SpringBoot项目中实现Excel上传功能的相关方法,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下
    2025-09-09
  • 在分布式环境下正确使用MyBatis二级缓存的最佳实践

    在分布式环境下正确使用MyBatis二级缓存的最佳实践

    缓存就是内存中的数据,常常来自对数据库查询结果的保存,使用缓存,我们可以避免频繁与数据库进行交互,从而提高响应速度,这篇文章主要介绍了在分布式环境下正确使用MyBatis二级缓存的最佳实践,需要的朋友可以参考下
    2025-08-08
  • 解决Swagger修改请求对象字段文档不更新问题

    解决Swagger修改请求对象字段文档不更新问题

    这篇文章主要为大家介绍了解决Swagger修改请求对象字段文档不更新的问题，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
    2022-05-05
  • springboot 集成activemq项目配置方法

    springboot 集成activemq项目配置方法

    这篇文章主要介绍了springboot 集成activemq项目配置方法,e-car项目配置通过引入activemq依赖,本文结合实例代码给大家介绍的非常详细,感兴趣的朋友跟随小编一起看看吧
    2024-04-04
  • Spring Cloud使用Feign进行远程调用的操作指南

    Spring Cloud使用Feign进行远程调用的操作指南

    本文介绍了Feign作为声明式HTTP客户端在SpringCloud中的使用,从简介、对比RestTemplate的问题、使用步骤,到日志配置、性能优化和实际应用进行了详细讲解,包括如何通过Feign简化接口调用,以及解决启动时找不到FeignClient的问题,需要的朋友可以参考下
    2025-02-02
  • 学习Java的Date、Calendar日期操作

    学习Java的Date、Calendar日期操作

    Java开发过程中避免不了日期相关操作，这篇文章总结了一些Date、Calendar的常用方法,需要的朋友可以参考下
    2015-07-07
  • Java项目中添加外部jar包的两种方式(收藏版)

    Java项目中添加外部jar包的两种方式(收藏版)

    这篇文章主要介绍了java项目中添加外部jar包的两种方式,第二种方式是将外部jar包引入到本地maven仓库中，本文给大家讲解的非常详细，需要的朋友可以参考下
    2023-03-03
  • JavaSE网络原理之UDP和TCP原理详解

    JavaSE网络原理之UDP和TCP原理详解

    TCP、UDP都是属于运输层的协议,提供端到端的进程之间的逻辑通信,而IP协议是提供主机间的逻辑通信,应用层规定应用进程在通信时所遵循的协议,这篇文章主要介绍了JavaSE网络原理之UDP和TCP原理的相关资料,需要的朋友可以参考下
    2026-01-01
  • Java中的RabbitMQ使用场景和实践完全指南

    Java中的RabbitMQ使用场景和实践完全指南

    本文涵盖了RabbitMQ在Java中的主要使用场景和实践方法,在实际应用中,还需要根据具体的业务需求和系统架构进行适当的调整和优化,本文结合代码给大家介绍的非常详细,感兴趣的朋友跟随小编一起看看吧
    2025-08-08
  • Java 是如何利用接口避免函数回调的方法

    Java 是如何利用接口避免函数回调的方法

    本篇文章主要介绍了Java 是如何利用接口避免函数回调的方法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
    2018-02-02

最新评论