Java对象内存布局与Synchronized锁升级

Java对象内存布局

对象在堆内存中布局

• 对象内部结构分为：对象头（Header）、实例数据（Instance data）、对齐填充（padding）（保证8个字节的倍数）。

• 对象头分为：对象标记（Mark Word）和类元信息（Class Pointer）。

• 在64位系统中，Mark Word占了8个字节，类型指针占了8个字节，一共是16个字节。

Synchronized与锁升级

Synchronized

为什么每一个对象都可以成为一个锁？？？？

• 管程(Monitors，也称为监视器)是一种程序结构，结构内的多个子程序〈对象或模块〉形成的多个工作线程互斥访问共享资源。
• 这些共享资源一般是硬件设备或一群变量。对共享变量能够进行的所有操作集中在一个模块中。(把信号量及其操作原语“封装”在一个对象内部)管程实现了在一个时间点，最多只有一个线程在执行管程的某个子程序。
• 管程提供了一种机制，管程可以看做一个软件模块，它是将共享的变量和对于这些共享变量的操作封装起来，形成一个具有一定接口的功能模块，进程可以调用管程来实现进程级别的并发控制。

因为在Java的设计中 ，每一个Java对象天生就带了一把看不见的锁，它叫做内部锁或者Monitor锁。

Monitor与java对象以及线程是如何关联 ？？？

• 如果一个java对象被某个线程锁住，则该java对象的Mark Word字段中LockWord指向monitor的起始地址
• Monitor的Owner字段会存放拥有相关联对象锁的线程id

Synchronized使用总结

• 作用于实例方法，当前实例加锁，进入同步代码前要获得当前实例的锁。
• 作用于代码块，对括号里配置的对象加锁。
• 作用于静态方法，当前类加锁，进去同步代码前要获得当前类对象的锁。

Synchronized锁升级

• synchronized属于重量级锁，效率低下，因为监视器锁（monitor）是依赖于底层的操作系统的Mutex Lock来实现的，挂起线程和恢复线程都需要转入内核态去完成，阻塞或唤醒一个Java线程需要操作系统切换CPU状态来完成，这种状态切换需要耗费处理器大量时间。
• Java 6之后，为了减少获得锁和释放锁所带来的性能消耗，引入了轻量级锁和偏向锁。

锁升级过程

• synchronized锁：由对象头中的Mark Word根据锁标志位的不同而被复用及锁升级策略

偏向锁

竞争线程尝试CAS更新对象头失败，发生锁升级，成功则重新偏向。

• 第一个线程正在执行synchronized方法(处于同步块)，它还没有执行完，其它线程来抢夺CAS失败，该偏向锁会被取消掉并出现锁升级（轻量级锁）。此时轻量级锁由原持有偏向锁的线程持有，继续执行其同步代码，而正在竞争的线程会进入自旋等待获得该轻量级锁。
• 第一个线程执行完成synchronized方法(退出同步块)，其它线程来抢夺CAS成功，则将对象头设置成无锁状态并撤销偏向锁，重新偏向 。

轻量级锁

轻量级锁是为了在线程近乎交替执行同步块时提高性能。

• 争夺轻量级锁失败时，CAS自旋尝试抢占锁。
• JVM自适应CAS自旋的次数，判断是否升级为重量级锁

重量级锁

• 线程竞争不使用自旋，不会消耗CPU
• 线程阻塞，响应时间缓慢

总结

• synchronized锁升级过程总结：先自旋，不行再阻塞。

• 偏向锁：适用于单线程适用的情况，在不存在锁竞争的时候进入同步方法/代码块则使用偏向锁。

• 轻量级锁：适用于竞争较不激烈的情况(这和乐观锁的使用范围类似)， 存在竞争时升级为轻量级锁，轻量级锁采用的是自旋锁，如果同步方法/代码块执行时间很短的话，采用轻量级锁虽然会占用cpu资源但是相对比使用重量级锁还是更高效。

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

锁升级后hashcode之去哪了？？？

• 无锁状态下，Mark Word中可以存储对象的identity hash code值。当对象的hashCode()方法第一次被调用时，JVM会生成对应的identity hash code值并将该值存储到Mark Word中。

• 对于偏向锁，在线程获取偏向锁时，会用Thread ID和epoch值覆盖identity hash code所在的位置。如果一个对象的hashCode()方法已经被调用过一次之后，这个对象不能被设置偏向锁。因为如果可以的化，那Mark Word中的identity hash code必然会被偏向线程ld给覆盖，这就会造成同一个对象前后两次调用hashCode()方法得到的结果不一致。

• 升级为轻量级锁时，JVM会在当前线程的栈帧中创建一个锁记录(Lock Record)空间，用于存储锁对象的MarkWord拷贝，该拷贝中可以包含identity hash code，所以轻量级锁可以和identity hashcode共存，哈希码和GC年龄自然保存在此，释放锁后会将这些信息写回到对象头。

• 升级为重量级锁后，Mark Word保存的重量级锁指针，代表重量级锁的ObjectMonitor类里有字段记录非加锁状态下的MarkWord，锁释放后也会将信息写回到对象头。

JIT编译器对锁的优化

Just In Time Compiler，一般翻译为即时编译器。

锁消除

不是公共锁，这个锁对象并没有被共用扩散到其它线程使用，每个线程各一把锁，JIT就会无视。

/**
 * 锁消除
 * 从JIT角度看相当于无视它，synchronized (o)不存在了,这个锁对象并没有被共用扩散到其它线程使用，
 * 不是公共锁，每个线程各一把锁
 */
public class LockClearTest {


    public void m1()
    {
        //锁消除,JIT会无视它，synchronized(对象锁)不存在了。不是公共锁，每个线程各一把锁
        Object o = new Object();

        synchronized (o)
        {
            System.out.println("-----hello LockClearTest");
        }
    }

    public static void main(String[] args)
    {
        LockClearTest demo = new LockClearTest();

        for (int i = 1; i <=10; i++) {
            new Thread(() -> {
                demo.m1();
            },String.valueOf(i)).start();
        }
    }
}

锁粗化

假如方法中首尾相接，前后相邻的都是同一个锁对象，那JIT编译器就会把这几个synchronized块合并成一个大块，加粗加大范围，一次申请锁使用即可，避免次次的申请和释放锁，提升了性能。

/**
 * 锁粗化
 * 假如方法中首尾相接，前后相邻的都是同一个锁对象，那JIT编译器就会把这几个synchronized块合并成一个大块，
 * 加粗加大范围，一次申请锁使用即可，避免次次的申请和释放锁，提升了性能
 */
public class LockBigTest {

    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");
            }
            //锁粗化,JIT编译器就会把这几个synchronized块合并成一个大块执行
            synchronized (objectLock) {
                System.out.println("11111");
                System.out.println("22222");
                System.out.println("33333");
            }
        },"a").start();

    }

}