JAVA技术-synchronized关键字

代码小郭

于 2023-07-25 10:28:40 发布

阅读量189

点赞数

分类专栏：个人博客文章 java 文章标签： java

本文链接：https://blog.csdn.net/u011208987/article/details/131912119

版权

个人博客文章同时被 2 个专栏收录

17 篇文章 0 订阅

订阅专栏

java

13 篇文章 0 订阅

订阅专栏

个人网站: www.gydblog.com

01、简介

在多线程并发编程中 synchronized 是历史很悠久的概念，它可以用于修饰实例方法、静态方法、代码块。当一个线程试图访问同步代码时必须首先获得锁，正常退出或者抛出异常时必须释放锁。由于会导致争用不到锁的线程进入阻塞状态，涉及到用户态和内核态的操作系统级别的切换动作，因此很多人都会称呼synchronized为重量级锁。

但是，随着 Java SE 1.5以后对 synchronized 进行了各种优化之后，有些情况下它就并不那么重了。Java SE 1.6 中为了减少获得锁和释放锁带来的性能消耗而引入了无锁状态、偏向锁、轻量级锁、重量级锁、自旋等一系列锁升级概念。

这里顺便提一下阿里开发手册中的几个用锁原则：

尽可能使加锁的代码块工作量尽可能的小，避免在锁代码块中调用rpc方法或者耗时的io操作。
能锁代码块，就不要锁整个方法体；能用对象锁，就不要用类锁。

下面是synchronized的三种应用场景：

02、修饰实例方法

一个对象里如果有多个synchronized方法，某一个时刻内，只要有一个线程去调用其中的任何一个synchronized方法了，其它的线程都只能等待，也就是说，某一个时刻内，只能有一个线程去访问这些synchronized方法。synchronized锁的是当前对象this，被锁定后，其它的线程都不能进入到当前对象的其它的synchronized方法

package com.gyd;

public class LockDemo4 {
    public synchronized void m1(){
        System.out.println("----实例同步方法");
    }

    public void m2(){
        System.out.println("----普通方法");
     }
    public static void main(String[] args){
    }
}

作用于实例方法时，当前实例加锁，进入同步代码前要抢到当前实例的锁才可以继续执行，否则阻塞。

字节码分析

使用javap -v命令对上述代码的字节码文件LockDemo4.class进行反汇编，结果如下：

Classfile /D:/code/demo/target/classes/com/gyd/LockDemo4.class
  Last modified 2023-7-3; size 715 bytes
  MD5 checksum c2407a25c8e642fa676372e3ff28d4fd
  Compiled from "LockDemo4.java"
public class com.gyd.LockDemo4
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #7.#23         // java/lang/Object."<init>":()V
   #2 = Fieldref           #24.#25        // java/lang/System.out:Ljava/io/PrintStream;
   #3 = String             #26            // ----实例同步方法
   #4 = Methodref          #27.#28        // java/io/PrintStream.println:(Ljava/lang/String;)V
   #5 = String             #29            // ----普通方法
   #6 = Class              #30            // com/gyd/LockDemo4
   #7 = Class              #31            // java/lang/Object
   #8 = Utf8               <init>
   #9 = Utf8               ()V
  #10 = Utf8               Code
  #11 = Utf8               LineNumberTable
  #12 = Utf8               LocalVariableTable
  #13 = Utf8               this
  #14 = Utf8               Lcom/gyd/LockDemo4;
  #15 = Utf8               m1
  #16 = Utf8               m2
  #17 = Utf8               main
  #18 = Utf8               ([Ljava/lang/String;)V
  #19 = Utf8               args
  #20 = Utf8               [Ljava/lang/String;
  #21 = Utf8               SourceFile
  #22 = Utf8               LockDemo4.java
  #23 = NameAndType        #8:#9          // "<init>":()V
  #24 = Class              #32            // java/lang/System
  #25 = NameAndType        #33:#34        // out:Ljava/io/PrintStream;
  #26 = Utf8               ----实例同步方法
  #27 = Class              #35            // java/io/PrintStream
  #28 = NameAndType        #36:#37        // println:(Ljava/lang/String;)V
  #29 = Utf8               ----普通方法
  #30 = Utf8               com/gyd/LockDemo4
  #31 = Utf8               java/lang/Object
  #32 = Utf8               java/lang/System
  #33 = Utf8               out
  #34 = Utf8               Ljava/io/PrintStream;
  #35 = Utf8               java/io/PrintStream
  #36 = Utf8               println
  #37 = Utf8               (Ljava/lang/String;)V
{
  public com.gyd.LockDemo4();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 3: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Lcom/gyd/LockDemo4;

  public synchronized void m1();
    descriptor: ()V
    flags: ACC_PUBLIC, ACC_SYNCHRONIZED
    Code:
      stack=2, locals=1, args_size=1
         0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #3                  // String ----实例同步方法
         5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return
      LineNumberTable:
        line 5: 0
        line 6: 8
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       9     0  this   Lcom/gyd/LockDemo4;

  public void m2();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=1, args_size=1
         0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #5                  // String ----普通方法
         5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return
      LineNumberTable:
        line 9: 0
        line 10: 8
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       9     0  this   Lcom/gyd/LockDemo4;

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=0, locals=1, args_size=1
         0: return
      LineNumberTable:
        line 12: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       1     0  args   [Ljava/lang/String;
}
SourceFile: "LockDemo4.java"

在上面的汇编代码中，m1方法所在的第64行的ACC_SYNCHRONIZED是一个访问标志，有该标记的方法是一个实例同步方法。调用指令会检查方法的flag有没有设置ACC_SYNCHRONIZED访问标志。如果设置了，执行线程会先去抢占实例对象的monitor锁，然后再执行方法，最后在方法执行完后释放monitor锁(无论方法是正常完成还是异常完成)。而普通非同步方法如m2的方法头flag上就没有这个ACC_SYNCHRONIZED访问标志。

03、修饰静态方法

对于静态同步方法，锁的是当前类的class对象，所有该类的实例都受影响。也就是说一旦一个静态同步方法获取锁之后，其他的静态同步方法都必须等待该方法释放锁后才能获取锁。

package com.gyd;

public class LockDemo5 {
    public static synchronized void m1(){
        System.out.println("----静态同步方法");
    }

    public static void main(String[] args){
    }
}

作用于静态方法，当前类加锁，进入同步代码前要抢到当前类class对象的锁才可以继续执行，否则阻塞。

字节码分析

和普通同步方法一样，使用javap -v 命令对LockDemo5.clas进行反汇编，结果如下：

Classfile /D:/code/demo/target/classes/com/gyd/LockDemo5.class
  Last modified 2023-7-3; size 601 bytes
  MD5 checksum f1327a18fa7cda2fd388cf8ef3860aa5
  Compiled from "LockDemo5.java"
public class com.gyd.LockDemo5
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #6.#21         // java/lang/Object."<init>":()V
   #2 = Fieldref           #22.#23        // java/lang/System.out:Ljava/io/PrintStream;
   #3 = String             #24            // ----静态同步方法
   #4 = Methodref          #25.#26        // java/io/PrintStream.println:(Ljava/lang/String;)V
   #5 = Class              #27            // com/gyd/LockDemo5
   #6 = Class              #28            // java/lang/Object
   #7 = Utf8               <init>
   #8 = Utf8               ()V
   #9 = Utf8               Code
  #10 = Utf8               LineNumberTable
  #11 = Utf8               LocalVariableTable
  #12 = Utf8               this
  #13 = Utf8               Lcom/gyd/LockDemo5;
  #14 = Utf8               m1
  #15 = Utf8               main
  #16 = Utf8               ([Ljava/lang/String;)V
  #17 = Utf8               args
  #18 = Utf8               [Ljava/lang/String;
  #19 = Utf8               SourceFile
  #20 = Utf8               LockDemo5.java
  #21 = NameAndType        #7:#8          // "<init>":()V
  #22 = Class              #29            // java/lang/System
  #23 = NameAndType        #30:#31        // out:Ljava/io/PrintStream;
  #24 = Utf8               ----静态同步方法
  #25 = Class              #32            // java/io/PrintStream
  #26 = NameAndType        #33:#34        // println:(Ljava/lang/String;)V
  #27 = Utf8               com/gyd/LockDemo5
  #28 = Utf8               java/lang/Object
  #29 = Utf8               java/lang/System
  #30 = Utf8               out
  #31 = Utf8               Ljava/io/PrintStream;
  #32 = Utf8               java/io/PrintStream
  #33 = Utf8               println
  #34 = Utf8               (Ljava/lang/String;)V
{
  public com.gyd.LockDemo5();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 3: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Lcom/gyd/LockDemo5;

  public static synchronized void m1();
    descriptor: ()V
    flags: ACC_PUBLIC, ACC_STATIC, ACC_SYNCHRONIZED
    Code:
      stack=2, locals=0, args_size=0
         0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #3                  // String ----静态同步方法
         5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return
      LineNumberTable:
        line 5: 0
        line 6: 8

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=0, locals=1, args_size=1
         0: return
      LineNumberTable:
        line 9: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       1     0  args   [Ljava/lang/String;
}
SourceFile: "LockDemo5.java"

从上面的汇编结果可以看出，静态同步方法m1所在的flag除了ACC_SYNCHRONIZED访问标志，还多了一个ACC_STATIC标记。这就是用来区分普通同步方法的标志。其它和普通同步方法相同。

04、修饰同步代码块

锁的是 synchonized 括号里配置的对象。
使用示例：

package com.gyd;

public class LockDemo2 {

    Object object = new Object();
    public void m1(){
        synchronized (object) {
            System.out.println("----hello");
        }
        System.out.println("-other code---");
    }
    public static void main(String[] args){
    }
}

作用于代码块，是对括号里配置的对象加锁。

字节码分析

找到target目录下的字节码文件LockDemo2.class，使用javap命令对LockDemo2.class文件进行字节码反汇编，输入命令"javap -c .\LockDemo2.class"

结果如下：

Compiled from "LockDemo2.java"
public class com.gyd.LockDemo2 {
  java.lang.Object object;

  public com.gyd.LockDemo2();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: aload_0
       5: new           #2                  // class java/lang/Object
       8: dup
       9: invokespecial #1                  // Method java/lang/Object."<init>":()V
      12: putfield      #3                  // Field object:Ljava/lang/Object;
      15: return

  public void m1();
       6: monitorenter
       7: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;
      10: ldc           #5                  // String ----hello
      12: invokevirtual #6                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      15: aload_1
      16: monitorexit
      17: goto          25
      20: astore_2
      21: aload_1
      22: monitorexit
      23: aload_2
      24: athrow
      25: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;
      28: ldc           #7                  // String -同步代码块外的业务逻辑代码===
      30: invokevirtual #6                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      33: return
    Exception table:
       from    to  target type
           7    17    20   any
          20    23    20   any

  public static void main(java.lang.String[]);
    Code:
       0: return

从上述反编译生成代码分析可以看出第6行的monitorenter指令和第16行的monitorexit指令分别对应了同步代码块的开始和结束位置。而且还发现多了一个22行的monitorexit指令。可以得出结论：同步代码块至少会有一个monitorenter和一个monitorexit配对。monitorexit指令可能会有多个，这是java对发生异常时的特殊处理，保证异常情况时锁也能得到释放。

那么，如果在同步代码块范围内发生了未处理异常，java是怎么处理的呢？
我们再来看一个例子：

package com.gyd;

public class LockDemo3 {

    Object object = new Object();
    public void m1(){
        synchronized (object) {
            System.out.println("----hello");
            throw new RuntimeException("error");
        }
    }
    public static void main(String[] args){
    }
}

还是执行javap命令对LockDemo3.class字节码文件进行反汇编，得出如下结果：

Compiled from "LockDemo3.java"
public class com.gyd.LockDemo3 {
  java.lang.Object object;

  public com.gyd.LockDemo3();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: aload_0
       5: new           #2                  // class java/lang/Object
       8: dup
       9: invokespecial #1                  // Method java/lang/Object."<init>":()V
      12: putfield      #3                  // Field object:Ljava/lang/Object;
      15: return

  public void m1();
    Code:
       0: aload_0
       1: getfield      #3                  // Field object:Ljava/lang/Object;
       4: dup
       5: astore_1
       6: monitorenter
       7: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;
      10: ldc           #5                  // String ----hello
      12: invokevirtual #6                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      15: new           #7                  // class java/lang/RuntimeException
      18: dup
      19: ldc           #8                  // String error
      21: invokespecial #9                  // Method java/lang/RuntimeException."<init>":(Ljava/lang/String;)V
      24: athrow
      25: astore_2
      26: aload_1
      27: monitorexit
      28: aload_2
      29: athrow
    Exception table:
       from    to  target type
           7    28    25   any

  public static void main(java.lang.String[]);
    Code:
       0: return
}

从LockDemo3的汇编代码可以看出第6行出现一条monitorenter指令，第27行出现了一条monitorexit指令。这里要注意第24行和第29行出现了athrow指令，athrow代表一个异常的抛出定义。

从上述两种反汇编结果可以总结一个结论：使用同步块时，底层汇编代码一般情况会生成1个monitorenter指令和2个monitorexit指令。极端情况下是一个monitorenter和1个monitorexit指令。

05、Java对象头

synchronized 用的锁是存在 Java 对象头里的。如果对象是数组类型，则虚拟机用 3个字宽（Word）存储对象头，如果对象是非数组类型，则用 2 字宽存储对象头。在 32位虚拟机中，1字宽等于 4 字节，即 32bit，如表所示：

长度	内容	说明
32/64bit	Mark Word	存储对象的hashcode或锁信息等
32/64bit	Class Metadata Address	存储到对象类型数据的指针
32/64bit	Array Length	数组的长度(如果当前对象是数组)

synchronized锁升级过程和对象头的Mark Word区域有着密切关系，该区域主要存储HashCode、分代年龄和锁标记位等信息。32
位 JVM 的 Mark Word 的默认存储结构如表所示：

锁状态	25bit	4bit	1bit是否是偏向锁	2bit锁标志位
无锁状态	对象的hashcode	对象的分代年龄	0	01

在运行期间，synchronized锁触发升级时，Mark Word 里存储的数据会随着锁标志位的变化而变化。64位的操作系统中Mark Word
可能变化为存储以下几种数据：
在这里插入图片描述

06、锁升级过程

用户态和内核态的切换会消耗大量的系统资源，因为用户态和内核态都有各自专用的内存空间、寄存器等，用户态切换至内核态需要传递许多变量、参数给内核，
内核也需要保护好用户态在切换时的一些寄存器值、变量等，以便内核态调用结束后切换回用户态继续工作。

java早期版本中，synchronized属于重量级锁，效率低下，因为监视器(monitor)是依赖底层操作系统的Mutex Lock(系统互斥量)来实现的，挂起线程和恢复线程都需要从用户态切换到内核态去完成。

jdk1.6以后为了减少获得锁和释放锁带来的性能消耗，引入了多个锁状态，级别从低到高依次是无锁状态、偏向锁、轻量级锁、重量级锁状态，
这几个状态会随着竞争情况逐渐升级。锁的升级过程是不可逆的，也就是说偏向锁升级为轻量级锁后不能再降级为偏向锁，轻量级锁升级为重量级锁后也不能再降级为轻量级锁。
这种锁升级却不能降级的策略也是为了提高获得锁和释放锁的效率。
在这里插入图片描述

锁	优点	缺点	适用场景
无锁	-	-	-
偏向锁	单线程竞争，加锁和锁不需要额外的消耗，和执行普通非同步方法相比仅存在纳秒级别的差距	如果线程间存在锁竞争，则会带来额外的锁释放的消耗	适用于只有一个线程频繁访问同步块的场景
轻量级锁	竞争的线程不会阻塞，提高了程序的响应速度	如果始终得不到锁的线程，一直自旋会消耗CPU资源	追求响应时间、同步代码块执行速度非常快
重量级锁	线程竞争不使用自旋，不会消耗CPU	线程阻塞，响应时间缓慢	追求吞吐量、同步代码块执行时间较长

synchronized用到的锁是存在Java对象头里的MarkWord中，锁升级主要依赖MarkWord中锁的标志位和释放偏向锁标志位。

接下来我们来分析下锁升级过程，在分析之前先要引入一个jar包：

    <dependency>
      <groupId>org.openjdk.jol</groupId>
      <artifactId>jol-core</artifactId>
      <version>0.9</version>
    </dependency>

升级过程-无锁状态

编写代码：


import org.openjdk.jol.info.ClassLayout;

public class SynchronizedUpDemo {
    public static void main(String[] args) {
        Object object = new Object();
        //object.hashCode();
        //System.out.println("10进制："+object.hashCode());
        //System.out.println("16进制："+Integer.toHexString(object.hashCode()));
        //System.out.println("2进制："+Integer.toBinaryString(object.hashCode()));
        //输出对象内存布局
        System.out.println(ClassLayout.parseInstance(object).toPrintable());
    }

}

运行上述代码，输出结果如下：

java.lang.Object object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           01 00 00 00 (00000001 00000000 00000000 00000000) (1)  //Mark Word
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0) //class point指针
      8     4        (object header)                           e5 01 00 f8 (11100101 00000001 00000000 11111000) (-134217243)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

如果在打印内存布局前调用hashCode方法，会在对象头中存储生成的hashCode，输出结果如下：

10进制：1735600054
16进制：677327b6
2进制：1100111011100110010011110110110
java.lang.Object object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           01 b6 27 73 (00000001 10110110 00100111 01110011) (1931982337)  
      4     4        (object header)                           67 00 00 00 (01100111 00000000 00000000 00000000) (103)
      8     4        (object header)                           e5 01 00 f8 (11100101 00000001 00000000 11111000) (-134217243)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total


Process finished with exit code 0

上面两个程序的结果如何分析呢？我们从第二行的末尾往回看，每个8位字节从左往右看，可以得出无锁状态最后3位是001，这就是无锁状态锁标记位的值(详情查阅前面提到过的Mark Word存储区域介绍)

升级过程-偏向锁状态

偏向锁是指当线程A第一次竞争到锁时，通过操作修改MarkWord中的偏向线程ID。如果不存在其它新的线程来竞争，那么持有偏向锁的线程将永远不需要进行同步了，省去了加锁和解锁的过程。
偏向锁的出现是为了解决只有在一个线程执行同步时提高程序性能。

来看一个偏向锁的例子：


public class BiaseLockDemo {
    private int number = 30;

    Object lock = new Object();

    public void require(){
        synchronized (lock){
            if (number > 0) {
                System.out.println(Thread.currentThread().getName()+" 抢到一个令牌");
                number--;
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        BiaseLockDemo biaseLockDemo = new BiaseLockDemo();
        new Thread(()->{for (int i=0;i<30;i++) {biaseLockDemo.require();}}).start();
        new Thread(()->{for (int i=0;i<30;i++) {biaseLockDemo.require();}}).start();
        new Thread(()->{for (int i=0;i<30;i++) {biaseLockDemo.require();}}).start();
        TimeUnit.SECONDS.sleep(5);
    }

}

上面程序启动了三个线程同时去抢令牌，令牌总量只有30个，运行该程序得到输出结果：

Thread-0 抢到一个令牌
Thread-0 抢到一个令牌
Thread-0 抢到一个令牌
Thread-0 抢到一个令牌
Thread-0 抢到一个令牌
Thread-0 抢到一个令牌
Thread-0 抢到一个令牌
Thread-0 抢到一个令牌
Thread-0 抢到一个令牌
Thread-0 抢到一个令牌
Thread-0 抢到一个令牌
Thread-0 抢到一个令牌
Thread-0 抢到一个令牌
Thread-0 抢到一个令牌
Thread-0 抢到一个令牌
Thread-0 抢到一个令牌
Thread-0 抢到一个令牌
Thread-0 抢到一个令牌
Thread-0 抢到一个令牌
Thread-0 抢到一个令牌
Thread-0 抢到一个令牌
Thread-0 抢到一个令牌
Thread-0 抢到一个令牌
Thread-0 抢到一个令牌
Thread-0 抢到一个令牌
Thread-0 抢到一个令牌
Thread-0 抢到一个令牌
Thread-0 抢到一个令牌
Thread-0 抢到一个令牌
Thread-0 抢到一个令牌

Process finished with exit code 0

我们发现，大部分情况令牌都会被其中一个线程获得，该线程被偏爱了，这就是偏向锁的效果了。

多次运行上面程序，也会存在不同线程都获得部分令牌的情况，这就是出现了线程竞争。线程竞争的情况分为下面几种：

竞争成功
竞争失败

07、参考资料

《Java并发编程的艺术》
《JUC并发编程与源码分析》

代码小郭

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA技术-synchronized关键字

在多线程并发编程中 synchronized 是历史很悠久的概念，它可以用于修饰实例方法、静态方法、代码块。当一个线程试图访问同步代码时必须首先获得锁，正常退出或者抛出异常时必须释放锁。由于会导致争用不到锁的线程进入阻塞状态，涉及到用户态和内核态的操作系统级别的切换动作，因此很多人都会称呼synchronized为重量级锁。但是，随着 Java SE 1.5以后对 synchronized 进行了各种优化之后，有些情况下它就并不那么重了。
复制链接

扫一扫