脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → 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的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:

相关文章

  • Java数据结构之栈的基本定义与实现方法示例

    Java数据结构之栈的基本定义与实现方法示例

    这篇文章主要介绍了Java数据结构之栈的基本定义与实现方法,简单描述了数据结构中栈的功能、原理,并结合java实例形式分析了栈的基本定义与使用方法,需要的朋友可以参考下
    2017-10-10
  • JDK常用命令jps jinfo jstat的具体说明与示例

    JDK常用命令jps jinfo jstat的具体说明与示例

    JDK本身提供了很多方便的JVM性能调优监控工具，除了集成式的VisualVM和jConsole外，还有jps、jinfo、jstat等小巧的工具，本文章希望能起抛砖引玉之用，让大家能开始对JVM性能调优的常用工具有所了解
    2021-09-09
  • linux系统下查看jdk版本、路径及配置环境变量

    linux系统下查看jdk版本、路径及配置环境变量

    在Linux系统中,配置JDK环境变量是非常重要的,它可以让你在终端中直接使用Java命令,这篇文章主要给大家介绍了关于linux系统下查看jdk版本、路径及配置环境变量的相关资料,需要的朋友可以参考下
    2024-01-01
  • Java数据结构之二叉搜索树详解

    Java数据结构之二叉搜索树详解

    二叉搜索树作为一个经典的数据结构，具有链表的快速插入与删除的特点，同时查询效率也很优秀，所以应用十分广泛。本文将详细讲讲二叉搜索树的原理与实现，需要的可以参考一下
    2022-06-06
  • java评论、回复功能设计与实现方法

    java评论、回复功能设计与实现方法

    很多项目或者系统都有评论或者回复的需求,但评论回复的实现往往都比较复杂,也不好实现,下面这篇文章主要给大家介绍了关于java评论、回复功能设计与实现的相关资料,需要的朋友可以参考下
    2022-06-06
  • SpringMVC拦截器配置及运行流程解析

    SpringMVC拦截器配置及运行流程解析

    这篇文章主要介绍了SpringMVC拦截器配置及运行流程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
    2020-06-06
  • java中类和对象的知识点总结

    java中类和对象的知识点总结

    在本篇文章里小编给大家整理了一篇关于java中类和对象的知识点总结，有需要的朋友们可以学习下。
    2020-12-12
  • Springboot自定义全局异常问题

    Springboot自定义全局异常问题

    这篇文章主要介绍了Springboot自定义全局异常问题,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
    2024-05-05
  • SpringBoot MDC全局链路最新完美解决方案

    SpringBoot MDC全局链路最新完美解决方案

    MDC 在 Spring Boot 中的作用是为日志事件提供上下文信息，并将其与特定的请求、线程或操作关联起来，通过使用 MDC，可以更好地理解和分析日志，并在多线程环境中确保日志的准确性和一致性，这篇文章主要介绍了SpringBoot MDC全局链路解决方案,需要的朋友可以参考下
    2023-08-08
  • 快速排序算法在Java中的实现

    快速排序算法在Java中的实现

    这篇文章主要介绍了快速排序算法在Java中的实现，简单介绍了快速排序的实现原理，分享了两种实现代码，具有一定参考价值，需要的朋友可以了解下。
    2017-11-11

最新评论