synchronized不同位置的实现原理

1、synchronized加在不同位置的区别

• 普通同步方法，锁的是当前实例对象

• 对于同步代码块，锁的是Synchronized括号中的代码块

• 静态同步方法，锁的是当前Class对象

2、synchronized加在不同位置的实现方式

1、不用锁

首先用一个简单的代码来测试一下，有啥区别，首先是不加锁的正常代码，代码如下：

public class Test {
    public static void main(String[] args) {
        new Test().hello();
    }

    public void hello(){
        System.out.println("hello world");
    }
}

对其字节码文件用javap命令处理一下，编译并找到Test.class，使用 javap -v Test 命令

//这里我只截取了后面一部分主要的，前面的内容省略了。
public void hello();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=1, args_size=1
         0: getstatic     #5                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #6                  // String hello world
         5: invokevirtual #7                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return
      LineNumberTable:
        line 16: 0
        line 17: 8
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       9     0  this   LTest;

2、锁代码块实现

然后将代码变成如下：

public class Test {
    public static void main(String[] args) {
        new Test().hello();
    }

    public void hello(){
        //锁同步代码块
        synchronized (this){
            System.out.println("hello world");
        }
    }
}

重新编译后再次运行命令，得到如下结果。

//其余部分省略
//这是加了锁的字节码
public void hello();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=3, args_size=1
         0: aload_0
         1: dup
         2: astore_1
         3: monitorenter
         4: getstatic     #5                  // Field java/lang/System.out:Ljava/io/PrintStream;
         7: ldc           #6                  // String hello world
         9: invokevirtual #7                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
        12: aload_1
        13: monitorexit
        14: goto          22
        17: astore_2
        18: aload_1
        19: monitorexit
        20: aload_2
        21: athrow
        22: return
      Exception table:
         from    to  target type
             4    14    17   any
            17    20    17   any
      LineNumberTable:
        line 16: 0
        line 17: 4
        line 18: 12
        line 19: 22
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      23     0  this   LTest;
      StackMapTable: number_of_entries = 2
        frame_type = 255 /* full_frame */
          offset_delta = 17
          locals = [ class Test, class java/lang/Object ]
          stack = [ class java/lang/Throwable ]
        frame_type = 250 /* chop */
          offset_delta = 4

总结

对比发现，加了synchronized的多了很多东西，最明显的区别，多了monitorenter和monitorexit指令，也就是说，对于同步代码块，原理是在同步块的入口位置和退出位置分别插入monitorenter和monitorexit字节码指令，但是发现似乎多了一个monitorexit指令，这是为啥呢？这里是因为第一个monitorexit指令是同步代码块正常释放锁的一个标志，如果同步代码块中出现Exception或者Error，则会调用第二个monitorexit指令来保证释放锁，资料来源：
synchronized反汇编为什么有两个monitorexit

3、锁方法块实现

将代码再改一改，如下：

public class Test {
    public static void main(String[] args) {
        new Test().hello();
    }

    //锁方法
    public synchronized void hello(){
        System.out.println("hello world");
    }
}

//其余部分省略
public synchronized void hello();
    descriptor: ()V
    flags: ACC_PUBLIC, ACC_SYNCHRONIZED
    Code:
      stack=2, locals=1, args_size=1
         0: getstatic     #5                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #6                  // String hello world
         5: invokevirtual #7                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return
      LineNumberTable:
        line 16: 0
        line 17: 8
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       9     0  this   LTest;

总结

发现在方法上加锁的Code属性和不加锁的内容一模一样，然后仔细观察，发现flags属性比不加锁的多了一个ACC_SYNCHRONIZED标识，那么锁方法的实现并不是加monitorenter和monitorexit指令，而是在方法修饰标识那里加了一个ACC_SYNCHRONIZED标识，其实这也是符合常理的，因为它锁住的是整个方法，如果在Code里面加的话，那就每个线程就会同时进入这个方法，然后在判断是否取得锁，这样是不合理的，合理的应该是进入这个方法前去判断，线程是否取得锁，如果线程取得锁，那么就运行，反之就等待。

3、静态方法加锁

1、猜测

那么在静态方法加锁，不变的是，锁在方法上，只是这个方法是静态的，那么是不是和锁方法一样，在flags上添加ACC_SYNCHRONIZED标识，然后静态方法就是在flags上添加ACC_STATIC标识。

2、验证

修改代码如下：

public class Test {
    public static void main(String[] args) {
        new Test().hello();
    }

    public synchronized static void hello(){
        System.out.println("hello world");
    }
}

用javap反编译一下，得到如下结果：

//其余部分省略
public static synchronized void hello();
    descriptor: ()V
    flags: ACC_PUBLIC, ACC_STATIC, ACC_SYNCHRONIZED
    Code:
      stack=2, locals=0, args_size=0
         0: getstatic     #5                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #6                  // String hello world
         5: invokevirtual #7                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return
      LineNumberTable:
        line 16: 0
        line 17: 8

总结

和猜想的一样，只是在flags上加了一个ACC_STATIC标识，区别就变成静态方法和非静态方法的区别了。

总结

1. 同步代码块即锁住对象是在同步代码块前后分别添加 monitorenter 和 monitorexit 指令,只有当锁住的对象的对象头(后续会聊到)中的线程指针指向的那个线程才能执行同步代码块中的的代码，而其他线程则需要等待。
2. 同步方法即在方法上进行加锁，和同步代码快不同，只是加了一个ACC_SYNCHRONIZED 标识。