synchronized的优化——轻量级锁、锁消除

1.轻量级锁：针对多个线程在不同时间访问同一把锁的情况

(1) 加锁：

• 线程在执行同步块之前，JVM会在当前线程的栈桢中创建用于存储锁记录的空间，并将对象头中的Mark Word复制到锁记录中，复制的这个称作Displaced Mark Word。
• 线程尝试使用CAS操作将对象头中的Mark Word替换为指向锁记录的指针。
• 如果成功，则成功获取锁；如果失败，表示有其他线程竞争锁，当前线程则自旋来获取锁。

(2) 解锁：

• 轻量级锁解锁时，会使用CAS操作将Displaced Mark Word替换回对象头；
• 若替换成功，说明没有竞争，成功释放；
• 若替换失败，说明此时存在竞争，则升级为重量级锁。

(3) 轻量级锁状态下64位Mark Word：

2.重量级锁：针对多个线程同一时刻访问同一资源的情况

(1) 过程：
重量级锁其实就是JDK1.6以前的synchronized同步机制，基于monitor计数器机制，JVM会阻塞加锁失败的线程，当锁释放之后，再唤醒这些阻塞的线程。JVM采用自适应自旋来减少性能损失。

(2) 重量级锁状态下64位Mark Word：

3.锁粗化：
锁粗化其实就是将多次拼接在一起的加锁、解锁操作合并为一次，将多个连续的锁扩展为一个范围更大的锁。代码示例如下：

public class StrTest {
    public static void main(String[] args) {
        StringBuffer str = new StringBuffer();
        str.append(1);
        str.append(2);
        str.append(3);
        System.out.println(str);
    }
}

上述代码其实在每次append()时，都会进行加锁、解锁操作，当虚拟机检测到有一连串的对同一个对象的加锁解锁操作时，就会在第一次append()时加锁，最后一次append()后解锁。如下代码：

public class StrTest {
    private static StringBuffer safeStr = new StringBuffer();
    public static void main(String[] args) {
        StringBuilder str = new StringBuilder();
        str.append(1);
        str.append(2);
        str.append(3);
        safeStr.append(str);
        System.out.println(safeStr);
    }
}

结果如下：

可以看出，此时只进行了一次加锁与解锁操作。

4.锁消除：
锁消除即是删除不必要的加锁操作。如下代码：

我们都知道，StringBuffer效率比较低，因为是线程安全的。但其实此时并不需要加锁，因为str是一个局部变量，不会从该方法上逃逸出去，本身就是线程安全的，所以我们可以使用StringBuilder来完成相同的工作，效率会更高。

public class StrTest {
    public static void main(String[] args) {
        StringBuffer str = new StringBuffer();
        str.append("a");
        str.append("b");
        str.append("c");
        System.out.println(str);
    }
}

锁消除代码：

public class StrTest {
    public static void main(String[] args) {
        StringBuilder str = new StringBuilder();
        str.append("a");
        str.append("b");
        str.append("c");
        System.out.println(str);
    }
}

结果如下：

这样可以大大提高代码的效率。

5.死锁问题：
线程的同步其实就是希望同一时刻只能有一个线程拿到锁执行代码，没有拿到锁的线程要等到持有锁的线程释放锁之后才可以获取锁，从而继续执行。

而线程的死锁其实就是几个线程都持有锁，但是都在互相等待着，都不释放锁，造成了线程死锁，程序终止。

示例代码如下：

class Man{}

class Women{}

public class DeadTest {
    public static void main(String[] args) {
        Man man = new Man();
        Women women = new Women();
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (man){
                    System.out.println("man");
                    synchronized (women){
                        System.out.println("woman");
                    }
                }
            }
        });
        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (women){
                    System.out.println("woman");
                    synchronized (man){
                        System.out.println("man");
                    }
                }
            }
        });
        thread1.start();
        thread2.start();
    }
}

结果如下：

可见，此时线程死锁，无法继续执行，导致程序停止。