synchronized详解

关于synchronized，本文从使用方法，底层原理和锁的升级优化这几个方面来介绍。

1.synchronized的使用：

synchronized可以保证在同一时刻，只有一个线程可以操作共享变量，并且该共享变量的变化对其他线程可见。它的使用方法有三种：

1.1 作用于实例方法

当synchronized作用于实例方法时，它的锁是当前的实例对象。通过以下demo来看下它的用法：

public class SynchronizedDemo implements Runnable{

    static int i = 0;
    
    // 作用于实例方法
    public synchronized void increase(){
        i++;
    }
    
    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            increase();
        }
    }
    
    public static void main(String[] args) throws InterruptedException {
        SynchronizedDemo synchronizedDemo = new SynchronizedDemo();
        Thread t1 = new Thread(synchronizedDemo);
        Thread t2 = new Thread(synchronizedDemo);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(i);
    }

}

以上demo的输出结果是：20000；在java中，任意一个对象都可以作为锁，注意在这里线程t1和t2共用了一把锁，都是synchronizedDemo这个对象。再看下，如下demo：

public class SynchronizedDemo implements Runnable{

    static int i = 0;
    
    public synchronized void increase(){
        i++;
    }
    
    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            increase();
        }
    }
    
    public static void main(String[] args) throws InterruptedException {
        SynchronizedDemo synchronizedDemo = new SynchronizedDemo();
        SynchronizedDemo synchronizedDemo2 = new SynchronizedDemo();
        Thread t1 = new Thread(synchronizedDemo);
        Thread t2 = new Thread(synchronizedDemo2);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(i);
    }

}

这个demo会出现什么结果呢？通过多次运行我们发现，输出的值可能会小于20000；原因就是线程t1和t2使用了各自的锁，那么synchronized的存在就毫无意义了，无法保证线程安全。那么针对这种有多个对象（锁）的情况，如何解决呢？将synchronized作用于静态方法就行了。

1.2 作用于静态方法

当作用于静态方法时，锁是当前类的class对象。看如下demo：

public class SynchronizedDemo implements Runnable{

    static int i = 0;
    
    public static synchronized void increase(){
        i++;
    }
    
    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            increase();
        }
    }
    
    public static void main(String[] args) throws InterruptedException {
        SynchronizedDemo synchronizedDemo = new SynchronizedDemo();
        SynchronizedDemo synchronizedDemo2 = new SynchronizedDemo();
        Thread t1 = new Thread(synchronizedDemo);
        Thread t2 = new Thread(synchronizedDemo2);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(i);
    }

}

运行结果：20000；此时是线程安全的，因为t1和t2共用了同一个锁，该锁就是SynchronizedDemo的class对象。

1.3 作用于代码块

当作用于代码块时，锁是synchronized括号里配置的对象。对于作用于代码块的使用场景是这样的：如果一个方法体很大，里面有一些耗时操作，但是我们需要同步的仅仅是一部分代码，如果对整个方法进行同步，显然是不合理的，所以可以针对代码块做同步。

 * @date 2018年9月25日
 */

public class SynchronizedDemo implements Runnable{

    static int x = 0;
    
    public void run() {
        
        //其他耗时操作。。。
        
        synchronized (SynchronizedDemo.class) {
            for (int i = 0; i < 10000; i++) {
                x++;
            }
        }
        
        
        //其他耗时操作。。。
    }
    
    public static void main(String[] args) throws InterruptedException {
        SynchronizedDemo synchronizedDemo = new SynchronizedDemo();
        Thread t1 = new Thread(synchronizedDemo);
        Thread t2 = new Thread(synchronizedDemo);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(x);
    }

}

在这个demo中，锁对象是SynchronizedDemo.class，当然可以是任意的java对象。

2.synchronized底层原理

synchronized在JVM中的实现原理，是基于进入和退出Monitor对象来实现方法同步和代码块同步，但是两者的实现细节不同；代码块同步是基于monitorenter和monitorexit指令来实现的，而方法同步是使用另外一种方式。在详解介绍之前，先了解下java对象头。

2.1 java对象头

在JVM中，对象在内存中的布局分为三块区域：对象头，实例变量和填充数据。而synchronized使用的锁对象就是存放在java对象头中的，对于java对象头由Mark Word和Class MetaData Address组成，如果当前对象是数据，则还有Array Length。如下图：

长度	内容	说明
32/64bit	Mark Word	存储对象的hashCode,锁信息，分代年龄或者GC标志信息
32/64bit	Class MetaData Address	存储到对象类型数据的指针，JVM通过这个指针能确定该对象是哪个类的实例
32/64bit	Array Length	如果当前对象是数组，则表示数组的长度

对于32位的JVM，Mark Word默认的存储结构如下：

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

在32位JVM下，除了上面的Mark Word默认的存储结构外，还有如下可变的的结构：

锁状态	25bit		4bit	1bit	2bit
	23bit	2bit		是否是偏向锁	锁标志位
轻量级锁	指向栈中锁记录的指针				00
重量级锁	指向重量级锁的指针				10
GC标记	空				11
偏向锁	线程ID	Epoch	对象粉黛年龄	1	01

在这里，synchronized的对象锁，锁标志位10，指针指向的是monitor对象的起始地址，每一个对象都有一个monitor对象与之关联。当一个monitor对象被一个线程持有后，它就处于锁定状态。

2.2 同步代码块底层原理

对于1.3中的demo，经过javap反编译后得到如下结果：

public class SynchronizedDemo implements java.lang.Runnable {
  static int x;

  public SynchronizedDemo();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":
()V
       4: return

  public void run();
    Code:
       0: ldc_w         #2                  // class SynchronizedDemo
       3: dup
       4: astore_1
       5: monitorenter                      // 进入同步方法
       6: iconst_0
       7: istore_2
       8: iload_2
       9: sipush        10000
      12: if_icmpge     29
      15: getstatic     #3                  // Field x:I
      18: iconst_1
      19: iadd
      20: putstatic     #3                  // Field x:I
      23: iinc          2, 1
      26: goto          8
      29: aload_1
      30: monitorexit                       // 退出同步方法
      31: goto          39
      34: astore_3
      35: aload_1
      36: monitorexit                      // 退出同步方法 
      37: aload_3
      38: athrow
      39: return
    Exception table:
       from    to  target type
           6    31    34   any
          34    37    34   any

  public static void main(java.lang.String[]) throws java.lang.InterruptedExcept
ion;
    Code:
       0: new           #2                  // class SynchronizedDemo
       3: dup
       4: invokespecial #4                  // Method "<init>":()V
       7: astore_1
       8: new           #5                  // class java/lang/Thread
      11: dup
      12: aload_1
      13: invokespecial #6                  // Method java/lang/Thread."<init>":
(Ljava/lang/Runnable;)V
      16: astore_2
      17: new           #5                  // class java/lang/Thread
      20: dup
      21: aload_1
      22: invokespecial #6                  // Method java/lang/Thread."<init>":
(Ljava/lang/Runnable;)V
      25: astore_3
      26: aload_2
      27: invokevirtual #7                  // Method java/lang/Thread.start:()V

      30: aload_3
      31: invokevirtual #7                  // Method java/lang/Thread.start:()V

      34: aload_2
      35: invokevirtual #8                  // Method java/lang/Thread.join:()V
      38: aload_3
      39: invokevirtual #8                  // Method java/lang/Thread.join:()V
      42: getstatic     #9                  // Field java/lang/System.out:Ljava/
io/PrintStream;
      45: getstatic     #3                  // Field x:I
      48: invokevirtual #10                 // Method java/io/PrintStream.printl
n:(I)V
      51: return

  static {};
    Code:
       0: iconst_0
       1: putstatic     #3                  // Field x:I
       4: return
}

monitorenter指令是在编译后插入到同步代码块的开始位置，monitorexit指令插入到同步代码块的结束位置和异常处，当线程执行到monitorenter指令时，将会尝试获取对象所对应的monitor的所有权，即尝试获取对象的锁。当monitorexit指令被执行时，执行线程会释放monitor锁。在上面的代码中可以看到，还有一个monitorexit指令，是在异常结束时执行的指令以释放monitor锁。对于同步方法的底层原理，细节实现上和这不同，这里暂时不做叙述。

3 锁的优化

在java SE1.6中，引入了偏向锁和轻量级锁，锁一共有四种状态，从低到高是：无锁状态，偏向锁状态，轻量级锁状态，重量级锁状态。这几种状态会随着竞争的提高，锁不断升级，但是不能降级。

3.1 偏向锁

 经研究发现，大多数情况下，锁不仅不存在竞争，而且总是由同一个线程多次获得。为了让线程获得锁的代价更低，所以就引入了偏向锁。当一个线程访问代码块并获取锁时，会在对象头和栈帧的锁记录里存储锁偏向的线程ID，以后线程当再次进入同步代码块时，不需要再加锁和解锁，只需要测试下该对象头中是否存储着指向该线程的偏向锁即可。注意，当没有锁竞争时，偏向锁有很好的优化效果，但是一旦锁竞争激烈，偏向锁就会失效，升级为轻量级锁。

3.1.1 偏向锁的撤销

偏向锁使用了一种竞争出现才释放锁的机制，所以当其他线程竞争偏向锁时，持有该偏向锁的线程才会释放锁，我们称之为偏向锁的撤销。流程如下：如果A线程正在持有一个偏向锁，当B线程竞争该偏向锁时，会暂停A线程，然后检查A线程是否还活着，如果A线程不处于活动状态，则将对象头设置为无锁状态；如果A线程还处于活动状态，则将对象头的锁偏向于B线程或者恢复到无锁，最后，唤醒A线程。

3.2 轻量级锁

3.2.1 轻量级锁加锁

线程尝试使用CAS将对象头中Mark Word替换为指向锁记录中的指针，如果成功，则获取锁成功。如果失败，则继续通过自旋CAS来获取锁。

3.2.2 轻量级锁解锁

轻量级锁升级到重量级锁，是在轻量级锁解锁的过程中发生的。线程在获取锁的时候拷贝了对象头中的Mark Word；在它释放锁的时候发现在它持有锁期间有其它线程尝试获取锁，并且该线程对Mark Word做了修改，两者发现不一致，则切换到重量级锁。

参考资料：《java并发编程的艺术》