synchronized使用和原理，你都清楚了吗？

synchronized是Java提供的一个用于并发控制的关键字，在平时的程序开发过程中在做并发控制的时候经常会使用到，但有时使用不当，不仅没有控制住并发，反而会导致系统问题，尤其在一些对并发要求比较高的场景会造成事故。

因此，有必要对synchronized进行一次系统的学习，把相关的知识梳理一遍，这样可以减少在开发过程中少走弯路，写出更加优雅的代码。

本文主要进行两个方面的分享：

1. synchronized关键字的使用场景
2. synchronized关键字在底层的工作机制是什么样的

使用场景

在Java中，每一个对象都会有一个叫做Monitor(中文翻译为监视器)的锁。

synchronized修饰方法

先来看代码示例一：

public class Test {
  
  public static void main(String[] args) throws Exception{
        Test test = new Test();
        Thread t1 = new Thread(() -> test.m1());
    		t1.start()
        Thread t2 = new Thread(() -> test.m1());
    		t2.start();
    }

    public synchronized void m1() {
        System.out.println("m1");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

当线程t1访问test对象的synchronized关键字修饰的方法m1时，会给这个对象上锁，此时当有另一个线程t2访问该方法时会被阻塞，直到A线程执行完m1时，将锁释放掉，才能进入并执行m1方法。

上面的代码只是synchronized使用的一种情况，实际上可以分为两种：

一种是修饰普通方法

一种是修饰静态方法

它们都会给对象上锁，但是上锁的对象是不一样的。

上面的代码其实synchronized是在修饰的普通方法，它会给当前方法所在类的对象实例上锁，而修饰静态方法synchronized会给当前方法所在类的Class对象上锁。

来看下面的代码示例二：

public class Test {
  
  public static void main(String[] args) throws Exception{
        Test test = new Test();
        Thread t1 = new Thread(() -> test.m1());
    		t1.start()
        Thread t2 = new Thread(() -> test.m1());
    		t2.start();
    }

    public synchronized void m1() {
        System.out.println("m1");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
  
   public static synchronized void m2() {
     System.out.println("m2");
   }
}

当线程t1访问test对象的m1时，会给当前test对象的实例上加锁，而当线程t2访问test对象的m2时，会给当前对象的class对象加锁，因此当两个线程先后启动后，假设t1先执行m1，但由于t2访问对象的加锁目标和t1加锁的不同，所以t2不会受t1的执行而休眠3秒钟，会立即执行。

所以，如果在一个类中，一个线程访问用synchronized关键字修饰的普通方法，一个线程访问用synchronized关键字修饰的静态方法，则这两个对象的锁的目标是不一样的，因此互相之间不会影响。

另外，需要注意的是，如果一个类中，有两个都用synchronized关键字修饰的普通方法，一个线程访问其中一个时，另一个访问另一个会因为两个方法都具有相同的对象实例锁，因此另一个线程也会被阻塞。都用synchronized关键字修饰的静态方法，情况也是如此。

synchronized修饰代码块

除了synchronized关键字可以修饰方法以外，synchronized关键字还可以修饰代码块。

看一下代码示例三：

public class Test {
  
  public static void main(String[] args) throws Exception{
        Test test = new Test();
        Thread t1 = new Thread(() -> test.m1());
    		t1.start()
        Thread t2 = new Thread(() -> test.m1());
    		t2.start();
    }

    public void m1() {
      synchronized(this){
        System.out.println("m1");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
      }
    }
  
  public static void m2() {
    synchronized(Test.class) {
      System.out.println("m2");
    }
   }
}

当线程t1访问m1的时候，会对当前对象实例上锁，而当线程t2访问m2的时候，会对当前对象的class对象上锁，因此两个线程执行的时候不会互相受影响而被阻塞。在这里具体锁的控制和修饰方法类似。

两者的异同点

相同

两者都能给普通对象实例上锁和类的class对象上锁

区别

1.修饰方法是粗粒度的并发控制，某一时刻只能有一个线程访问被synchronized修饰的方法；而修饰代码块是一种更细粒度的并发控制，可以只对方法的局部代码进行并发控制，方法中代码块外的代码还可以被多个线程同时执行；

2.修饰代码块要比修饰方法的并发性能高；

底层原理

上面介绍了synchronized修饰符在方法和代码块中的应用，但这只是使用层面的内容。在方法或代码块上添加了它，就能进行并发控制，看起来并发控制很简单。本着知其然还要知其所以然的意愿，还需要了解下它在底层是如何做到这些的，一起来看下底层原理吧。

synchronized修饰符是Java的JDK提供的一个关键字，在底层是通过JVM来实现并发控制的。上面说过每一个Java对象都有一个Monitor锁，那么来看看synchronized修饰符通过编译器的编译后在字节码层面是什么样的。

以实例二为例

找到编译器编译后的class文件所在的目录, 通过jdk提供的命令javap -v Test反编译，得到下面的字节码

 public synchronized void m1();
    descriptor: ()V
    flags: ACC_PUBLIC, ACC_SYNCHRONIZED
    Code:
      stack=2, locals=2, args_size=1
         0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #3                  // String m1
         5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: ldc2_w        #5                  // long 3000l
        11: invokestatic  #7                  // Method java/lang/Thread.sleep:(J)V
        14: goto          22
        17: astore_1
        18: aload_1
        19: invokevirtual #9                  // Method java/lang/InterruptedException.printStackTrace:()V
        22: return
      

  public static synchronized void m2();
    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           #10                 // String m2
         5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return

通过上面的字节码可以看出，

一个是在普通方法添加synchronized修饰

在flags上出现了ACC_SYNCHRONIZED，当线程t1访问方法m1时，发现flag 有此ACC_SYNCHRONIZED标志，则会对当前对象实例加锁，此时当t2线程访问方法m1时，会检查flags上是否有此标志，如有则会看当前对象实例是否加锁，如果加锁，就进入阻塞状态，等待t1线程执行完毕释放锁，然后再次进入。

一个是在静态方法添加synchronized修饰

在flags上出现了ACC_STATIC, ACC_SYNCHRONIZED，当线程t1访问方法m1时，发现flag同时具有ACC_STATIC标志和ACC_SYNCHRONIZED标志，则会对当前对象的class对象加锁，此时当t2线程访问方法m1时，会检查flags上是否也有这两个标志，如果有则会看当前对象的class对象是否加锁，如果加锁，就进入阻塞状态，等待t1线程执行完毕释放锁，然后再次进入。

再来看代码三：

通过javap -v Test反编译后的字节码如下

 public void m1();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=4, args_size=1
         0: aload_0
         1: dup
         2: astore_1
         3: monitorenter
         4: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
         7: ldc           #3                  // String m1
         9: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
        12: ldc2_w        #5                  // long 3000l
        15: invokestatic  #7                  // Method java/lang/Thread.sleep:(J)V
        18: goto          26
        21: astore_2
        22: aload_2
        23: invokevirtual #9                  // Method java/lang/InterruptedException.printStackTrace:()V
        26: aload_1
        27: monitorexit
        28: goto          36
        31: astore_3
        32: aload_1
        33: monitorexit
        34: aload_3
        35: athrow
        36: return
      

  public static void m2();
    descriptor: ()V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=2, args_size=0
         0: ldc           #10                 // class Test
         2: dup
         3: astore_0
         4: monitorenter
         5: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
         8: ldc           #11                 // String m2
        10: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
        13: aload_0
        14: monitorexit
        15: goto          23
        18: astore_1
        19: aload_0
        20: monitorexit
        21: aload_1
        22: athrow
        23: return

通过上面的字节码可以看出，

一种是在对普通对象修饰synchronized修饰代码块

当t1调用方法m1时，检查flags有无ACC_SYNCHRONIZED标志和ACC_STATIC标志，如果没有，则发现执行过程中有monitorenter，则会对当前对象实例加锁，如果t2也调用方法，则也按如上过程，发现当前对象加锁，则会进入阻塞，等待t1执行完毕释放，然后进入执行。

一种是在class对象修饰synchronized修饰代码块

当t1调用方法m1时，检查flags有无ACC_SYNCHRONIZED标志和ACC_STATIC标志，如果有ACC_STATIC标志，没有ACC_SYNCHRONIZED，然后发现执行过程中有monitorenter，则会对当前class对象实例加锁，如果t2也调用方法，则也按如上过程，发现当前class对象加锁，则会进入阻塞，等待t1执行完毕释放，然后进入执行。

总结

1. jvm中的同步是基于进入与退出监视器对象(Monitor)来完成的。Monitor是通过C++来实现的，每个对象实例都有一个monitor对象，它会和java对象一起创造和销毁。当线程获取到monitor对象时，monitor是依赖于底层操作系统的mutex lock来实现互斥的，从而能够控制并发。

2. synchronized用在方法上，是通过flags的ACC_STATIC和monitorenter、monitorexit来控制加锁和释放锁

3. synchronized用在代码块上，是通过flags的ACC_STATIC, ACC_SYNCHRONIZED两个标志位来控制加锁和释放锁