synchronized 锁的种类及升级步骤

1 线程状态切换的代价

java的线程是映射到操作系统原生线程之上的，如果要阻塞或唤醒一个线程就需要操作系统介入，需要在户态与核心态之间切换，这种切换会消耗大量的系统资源，因为用户态与内核态都有各自专用的内存空间，专用的寄存器等，用户态切换至内核态需要传递给许多变量、参数给内核，内核也需要保护好用户态在切换时的一些寄存器值、变量等，以便内核态调用结束后切换回用户态继续工作。

在Java早期版本中，synchronized属于重量级锁，效率低下，因为监视器锁（monitor）是依赖于底层的操作系统的Mutex Lock来实现的，挂起线程和恢复线程都需要转入内核态去完成，阻塞或唤醒一个Java线程需要操作系统切换CPU状态来完成，这种状态切换需要耗费处理器时间，如果同步代码块中内容过于简单，这种切换的时间可能比用户代码执行的时间还长”，时间成本相对较高，这也是为什么早期的synchronized效率低的原因
Java 6之后，为了减少获得锁和释放锁所带来的性能消耗，引入了轻量级锁和偏向锁。

2 升级流程

Java 1.6为了减少获得锁和释放锁带来的性能消耗，引入了“偏向锁”和“轻量级锁”，在Java SE 1.6中，锁一共有4种状态，级别从低到高依次是：无锁状态、偏向锁状态、轻量级锁状态和重量级锁状态，这几个状态会随着竞争情况逐渐升级。锁可以升级但不能降级，意味着偏向锁升级成轻量级锁后不能降级成偏向锁。这种锁升级却不能降级的策略，目的是为了提高获得锁和释放锁的效率。

2.1 无锁

描述： 线程之间没有竞争。

public class SynchronizedTest {

	private static final Object object = new Object();


    public static void main(String[] args) {

        System.out.println(object.toString());

    }

}

2.2 偏向锁

在实际应用运行过程中发现，“锁总是同一个线程持有，很少发生竞争”，也就是说锁总是被第一个占用他的线程拥有，这个线程就是锁的偏向线程。

那么只需要在锁第一次被拥有的时候，记录下偏向线程ID。这样偏向线程就一直持有着锁(后续这个线程进入和退出这段加了同步锁的代码块时，不需要再次加锁和释放锁。而是直接比较对象头里面是否存储了指向当前线程的偏向锁)。

如果相等表示偏向锁是偏向于当前线程的，就不需要再尝试获得锁了，直到竞争发生才释放锁。以后每次同步，检查锁的偏向线程ID与当前线程ID是否一致，如果一致直接进入同步。无需每次加锁解锁都去CAS更新对象头。如果自始至终使用锁的线程只有一个，很明显偏向锁几乎没有额外开销，性能极高。

假如不一致意味着发生了竞争，锁已经不是总是偏向于同一个线程了，这时候可能需要升级变为轻量级锁，才能保证线程间公平竞争锁。偏向锁只有遇到其他线程尝试竞争偏向锁时，持有偏向锁的线程才会释放锁，线程是不会主动释放偏向锁的。

偏向锁的操作不用直接捅到操作系统，不涉及用户态到内核态转换，不必要直接升级为最高级。

public class SynchronizedTest {

    private static final Object object = new Object();


    public static void main(String[] args) {


        new Thread(() -> {
            synchronized (object) {
                System.out.println(object.toString());
            }
        }, "t1").start();


    }

}

2.3 轻量级锁

轻量级锁是为了在线程近乎交替执行同步块时提高性能。主要目的，在没有多线程竞争的前提下，通过CAS减少重量级锁使用操作系统互斥量产生的性能消耗，说白了先自旋再阻塞。

升级时机: 当关闭偏向锁功能或多线程竞争偏向锁会导致偏向锁升级为轻量级锁。

public class SynchronizedTest {

    private static final Object object = new Object();

    private static int num = 0;


    private static void add() {
        synchronized (object) {
            num++;
        }
    }


    public static void main(String[] args) throws InterruptedException {

        new Thread(() -> {
            for (int i = 0; i < 50; i++) {
                add();
            }
        }, "t1");

        new Thread(() -> {
            for (int i = 0; i < 50; i++) {
                add();
            }
        }, "t2");

    }

}

2.4 重量级锁

适用于竞争激烈的情况，如果同步方法/代码块执行时间很长，那么使用轻量级锁自旋带来的性能消耗就比使用重量级锁更严重，这时候就需要升级为重量级锁。

public class SynchronizedTest {

    private static final Object object = new Object();

    private static int num = 0;


    private static void add() {
        synchronized (object) {
            num++;
        }
    }


    public static void main(String[] args) throws InterruptedException {

        for (int i = 1; i <= 100; i++) {
            Thread thread = new Thread(() -> {
                for (int j = 1; j <= 10000; j++) {
                    add();
                }
            }, "t" + i);
            thread.start();
            thread.join();
        }


        System.out.println(num);
    }

}

3 JIT优化

JIT： 即时编译器。

3.1 锁消除

从JIT角度看相当于无视它，synchronized (o)不存在了,这个锁对象并没有被共用扩散到其它线程使用，

3.2 锁粗化

锁粗化就是告诉我们任何事情都有个度，有些情况下我们反而希望把很多次锁的请求合并成一个请求，以降低短时间内大量锁请求、同步、释放带来的性能损耗。

public class SynchronizedTest {

    private static final Object object = new Object();

    private static int num = 0;

    private static void add() {
        num++;
    }


    public static void main(String[] args) throws InterruptedException {

        for (int i = 1; i <= 100; i++) {
            Thread thread = new Thread(() -> {
                for (int j = 1; j <= 10000; j++) {
                    synchronized (object) {
                        add();
                    }
                    synchronized (object) {
                        add();
                    }
                    synchronized (object) {
                        add();
                    }
                    synchronized (object) {
                        add();
                    }
                    synchronized (object) {
                        add();
                    }
                }
            }, "t" + i);
            thread.start();
            thread.join();
        }


        System.out.println(num);
    }

}