关于synchronized的优化机制

synchronized的优化机制

• 锁分级
  对象头中包含了Mark Word，如下表示：
  

public class SynchronizedTest1 {

    private static List<Integer> list  = new Vector<>();
	/**
     * 关闭偏向锁 -XX:-UseBiasedLocking  675ms
     * 开启偏向锁 -XX:+UseBiasedLocking -XX:BiasedLockingStartupDelay=0 476ms
     */
    public static void main(String[] args){

        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000000; i++) {
            list.add(i);
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }

} 

• 锁粗化

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

    private static void someMethod(){
        Object object = new Object();
        synchronized (object){
            System.out.println(object);
        }
    }

JVM会通过逃逸分析去找到不存在共享数据也不存在竞争的代码，然后消除synchronized 。
发生了逃逸分析：局部变量从方法中返回赋值全局变量

public class SynchronizedTest3 {

    private Object object2 = null;

    public  void someMethod2(){
        this.object2 = someMethod();
    }

    private Object someMethod(){
        Object object = new Object();
        synchronized (object){
            return object;
        }
    }

}

• 锁消除
  将多个连续的加锁、解锁操作连接在一起，扩展成一个范围更大的锁。
  代码优化：可以将连续加锁的synchronized 的代码块，如果两段加synchronized 代码块之间的代码运行速度较快，可以直接写进同一个人synchronized 代码块里面。

public class SynchronizedTest4 {
	/**
     * 开启锁粗化  668ms
     * -server -XX:+DoEscapeAnalysis -XX:+EliminateLocks
     * 关闭锁粗化 822ms
     * -server -XX:-DoEscapeAnalysis -XX:-EliminateLocks
     */
    public static void main(String[] args){
        List<Integer> list = new Vector<>();
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000000; i++) {
            synchronized (list){
                list.add(i);
            }
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }

}