关于java:JAVA并发编程Synchronized与锁升级

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. 总结

锁降级的流程图片

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

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