1.Synchronized的性能变动

2.synchronized锁品种及降级步骤

3.JIT编译器对锁的优化

4.总结

1.Synchronized的性能变动
咱们都晓得synchronized关键字可能让程序串行化执行，保证数据的安全性，然而性能会降落。
所以java对synchronized进行了一系列的优化：
java5之前：
synchronized仅仅只是synchronized，这个操作是重量级别的操作，cpu在进入加锁的程序后，会进行用户态和内核态之间的切换。


用户态：用户态运行用户程序，级别较低
内核态：内核态运行操作系统程序，操作硬件，级别较高。

java如果要阻塞或者唤醒一个线程须要操作系统的接入，须要在用户态和外围态之间切换，因为synchronized属于重量级锁，是须要依赖底层操作系统的Mutex Lock来实现的，挂起线程和复原线程都须要进入内核态去实现，这种切换会耗费大量的系统资源，如果同步代码块中的内容过于简略，这种切换的工夫可能比用户代码的执行工夫还长，工夫老本太高，这也是为什么早起synchronized效率低的起因。

java6开始：
优化Synchronized，为了缩小取得锁和开释锁所带来的性能耗费，引入了偏差锁，轻量级锁和重量级锁（缩小了线程的阻塞和唤醒）。

2.synchronized锁品种及降级步骤
在说synchronized锁降级之前，咱们要先搞清楚，线程拜访一个synchronized润饰的办法，有三种类型：
1）只有一个线程来拜访，有且惟一。
2）有两个线程A,B来交替拜访
3）竞争强烈，多个线程来拜访

还记得咱们上一篇博客 JAVA并发编程——Java对象内存布局和对象头中提到了对象头，咱们先来看看这张图：

咱们能够看出synchronized用的锁是存在java对象头的Mark Word中，锁降级性能次要依赖Mark Word中锁标记位和开释偏差锁标记位。

java的锁降级依照
无锁->偏差锁->轻量级锁->重量级锁
咱们挨个进行解说。

无锁：
咱们先看一段无锁的代码

    public static void main(String[] args) {        //-XX:-UseCompressedClassPointers -XX:BiasedLockingStartupDelay=0        Object o = new Object();        System.out.println(ClassLayout.parseInstance(o).toPrintable());    }

这个对象没有应用锁，咱们看一下运行的后果。

这个输入的后果，对象头是倒着输入的，标红的中央便是锁标记位，当初是001，对应的对象头的图就是无锁状态。

偏差锁：
当一段同步代码始终被同一个线程屡次拜访，因为只有一个线程，那么该线程在后续拜访的时候，就会主动取得锁。（这个锁偏差了常常拜访的线程。）

在测试偏差锁之前，记得先输出jvm参数：-XX:+UseBiasedLocking -XX:BiasedLockingStartupDelay=0 因为偏差锁默认在jdk1.6之后默认是开启的，然而启动工夫有提早，所以须要手动增加参数，让偏差锁的延时工夫为0，在程序启动时立即开启。

        Object o = new Object();        new Thread(() -> {            synchronized (o){                System.out.println(ClassLayout.parseInstance(o).toPrintable());            }        },"t1").start();

运行后果为：

轻量级锁：
刚刚下面讲述的只是有一个线程正在争抢一个资源类，然而当初有另外线程来逐渐竞争锁的时候，就不能应用偏差锁了，要降级为轻量级锁。
在第一个线程正在执行synchronized办法（处于同步块），当它还没有执行完的时候，其它线程来争夺，竞争线程应用cas更新对象头失败，该偏差锁会被勾销并呈现锁降级。
此时轻量级锁由原持有偏差锁的线程持有，继续执行其同步代码，而正在竞争的线程会进入自旋期待获取该轻量级锁。

//敞开延时参数，启用该性能        Object o = new Object();        new Thread(() -> {            synchronized (o){                System.out.println(ClassLayout.parseInstance(o).toPrintable());            }        },"t1").start();

那么竞争到底自旋多少次会进行锁降级呢？

java6之前：
默认状况下自旋的次数为10次：-XX:PreBlockSpin=10
或者自旋次数超过cpu核数一半

java6之后：
自适应：意味着自旋次数是不固定的。
是依据：同一个锁上次自旋的工夫和领有锁线程的状态来确定。

偏差锁和自旋锁的区别：
抢夺轻量级锁失败的时候，自旋尝试抢占锁
轻量级锁每次退出同步代码块都须要开释锁，而偏差锁是在竞争产生时才开释锁。

重锁：
有大量线程正在抢占同一个资源类，冲突性很高，会升级成重量级锁。

        new Thread(() -> {            synchronized (o){                System.out.println(ClassLayout.parseInstance(o).toPrintable());            }        },"t1").start();        new Thread(() -> {            synchronized (o){                System.out.println(ClassLayout.parseInstance(o).toPrintable());            }        },"t2").start();        new Thread(() -> {            synchronized (o){                System.out.println(ClassLayout.parseInstance(o).toPrintable());            }        },"t3").start();

3.JIT编译器对锁的优化

1)锁打消
当只有一个线程运行synchronized代码的时候，默认会把锁打消，节俭资源。

/** * 锁打消* 从JIT角度看相当于忽视它，synchronized (o)不存在了,这个锁对象并没有被共用扩散到其它线程应用，* 极其的说就是基本没有加这个锁对象的底层机器码，打消了锁的应用*/public class LockClearUPDemo{static Object objectLock = new Object();//失常的public void m1()    {//锁打消,JIT会忽视它，synchronized(对象锁)不存在了。不失常的Object o = new Object();synchronized (o)        {            System.out.println("-----hello LockClearUPDemo"+"\t"+o.hashCode()+"\t"+objectLock.hashCode());        }    }public static void main(String[] args)    {        LockClearUPDemo demo = new LockClearUPDemo();for (int i = 1; i 10; i++) {new Thread(() -> {demo.m1();            },String.valueOf(i)).start();        }    }}

2)锁粗化
退出一个锁在同一个办法中，头尾相接，前后相邻的都是一个锁对象，那么编译器就会把这几个synchronized合并成一大块，加粗了范畴，节俭了资源。

/** * 锁粗化* 如果办法中首尾相接，前后相邻的都是同一个锁对象，那JIT编译器就会把这几个synchronized块合并成一个大块，* 加粗加大范畴，一次申请锁应用即可，防止次次的申请和开释锁，晋升了性能*/public class LockBigDemo{static Object objectLock = new Object();public static void main(String[] args)    {new Thread(() -> {synchronized (objectLock) {                System.out.println("11111");            }synchronized (objectLock) {                System.out.println("22222");            }synchronized (objectLock) {                System.out.println("33333");            }        },"a").start();new Thread(() -> {synchronized (objectLock) {                System.out.println("44444");            }synchronized (objectLock) {                System.out.println("55555");            }synchronized (objectLock) {                System.out.println("66666");            }        },"b").start();    }}

4.总结

锁降级的流程图片

锁长处毛病实用场景
偏差锁加锁和解锁不须要额定的耗费，和执行非同步办法只有纳秒的差距如果线程间存在锁竞争，会带来额定的锁撤销的耗费只有一个线程拜访同步块的场景
轻量级锁竞争的线程不会阻塞，进步了线程的相应速度始终得不到cpu的话，会空转，节约cpu谋求相应工夫，同步块执行速度十分快
重量级锁线程竞争不实用自旋，不耗费cpu线程阻塞，造成用户态和内核态的切换，响应工夫慢谋求数据一致性，同步执行块执行速度较长

锁降级用一句话概括：
先自旋，不行再阻塞。
就是把之前的乐观锁（重量级锁）在变成肯定条件下应用偏差锁以及应用轻量级锁。

synchronized在润饰办法和代码块在字节码上实现形式有很大差别，然而外部实现还是基于对象头的MarkWord来实现的。
JDK1.6之前synchronized应用的是重量级锁，JDK1.6之后进行了优化，领有了无锁->偏差锁->轻量级锁->重量级锁的降级过程，而不是无论什么状况都应用重量级锁。