文章目录

一线程安全问题
- 1.1 什么是线程安全问题？
- 1.2 自增运算真的线程安全吗？
- 1.3 Synchronized锁表现三种形势？
- - 1.3.1 synchronized同步方法
  - 1.3.2 synchronized同步代码块
  - 1.3.3 synchronized静态方法
  - 1.3.4 总结
二 Java对象结构与内置锁
- 2.1 Java对象结构
- - 2.2.1 对象头
  - 2.2.2 对象体
  - 2.2.3 对齐字节
  - 2.2.4 注意点
- 2.2 Mark Word 详细介绍
- 2.3 JOL工具查看对象的布局

Java内置锁是一个互斥锁，这就意味着最多只有一个线程能够获得该锁，当线程B尝试去获得线程A持有的内置锁时，线程B必须等待或者阻塞，直到线程A释放这个锁，如果线程A不释放这个锁，那么线程B将永远等待下去。线程进入同步代码块或方法时会自动获得该锁，在退出同步代码块或方法时会释放该锁。获得内置锁的唯一途径就是进入这个锁保护的同步代码块或方法。
aee901184d71990bfc44d6f3e75a667d_v2-f944239c363fd924bbc47d819ea416c5_1440w_source=172ae18b.jpg

一线程安全问题

1.1 什么是线程安全问题？

白话：当多个线程启动，对进程中同一资源进行操作时，可能会发生线程安全问题。
专业术语：当多个线程并发访问某个Java对象（Object）时，无论系统如何调度这些线程，也无论这些线程将如何交替操作，这个对象都能表现出一致的、正确的行为，那么对这个对象的操作是线程安全的。

1.2 自增运算真的线程安全吗？

案例

package class02;

/**
 * @description:
 * @author: shu
 * @createDate: 2022/11/3 19:55
 * @version: 1.0
 */
public class NotSafePlus {
    public Integer num=0;
    

    public Integer getNum() {
        return num;
    }

    public void setNum() {
        this.num ++;
    }
}

package class02;

/**
 * @description:
 * @author: shu
 * @createDate: 2022/11/3 19:57
 * @version: 1.0
 */

import java.util.concurrent.CountDownLatch;


public class PlusTest {
    static final int MAX_TREAD = 10;
    static final int MAX_TURN = 1000;

    public static void main(String[] args) throws InterruptedException {
        //倒数闩，需要倒数MAX_TREAD次
        CountDownLatch latch = new CountDownLatch(MAX_TREAD);

        NotSafePlus counter = new NotSafePlus();
        Runnable runnable = () ->
        {
            for (int i = 0; i < MAX_TURN; i++) {
                counter.setNum();
            }
            // 倒数闩减少一次
            latch.countDown();
        };
        for (int i = 0; i < MAX_TREAD; i++) {
            new Thread(runnable).start();
        }
        latch.await(); // 等待倒数闩的次数减少到0，所有的线程执行完成
        System.out.println("理论结果：" + MAX_TURN * MAX_TREAD);
        System.out.println("实际结果：" + counter.getNum());
        System.out.println("差距是：" + (MAX_TURN * MAX_TREAD - counter.getNum()));
    }
}

我们可以看出实际上在多线程环境中他并不是线程安全的，为啥？

原因

实际上，一个自增运算符是一个复合操作，至少包括三个JVM指令：内存取值寄，存器增加1和，存值到内存。
这三个指令在JVM内部是独立进行的，中间完全可能会出现多个线程并发进行。

JVM 字节码原因分析参考：https://blog.csdn.net/m0_49102380/article/details/123497368

改变

package class02;

/**
 * @description:
 * @author: shu
 * @createDate: 2022/11/3 19:55
 * @version: 1.0
 */
public class NotSafePlus {
    public Integer num=0;


    public Integer getNum() {
        return num;
    }

    public synchronized void setNum() {
        this.num ++;
    }
}

临界区资源表示一种可以被多个线程使用的公共资源或共享数据，但是每一次只能有一个线程使用它。
一旦临界区资源被占用，想使用该资源的其他线程则必须等待。
我们可以使用synchronized关键字同步代码块，对临界区代码段进行排他性保护，对此保证线程安全。

1.3 Synchronized锁表现三种形势？

在Java中，线程同步使用最多的方法是使用synchronized关键字。每个Java对象都隐含有一把锁，这里称为Java内置锁（或者对象锁、隐式锁）。使用synchronized（syncObject）调用相当于获取syncObject的内置锁，所以可以使用内置锁对临界区代码段进行排他性保护。
由于每一个Java对象都有一把监视锁，因此任何Java对象都能作为synchronized的同步锁。

对象锁：synchronized(this)以及非static的synchronized方法。锁的是这个对象。
类锁：synchronized(类名.class)和static 的synchronized方法。锁的是那个写了synchronized关键字的方法或者代码块。（static方法可以直接类名.方法名()调用，无法使用this，所以它锁的不是this，而是类的Class对象）

1.3.1 synchronized同步方法

package class02.Synchronized;

/**
 * @description: synchronized
 * @author: shu
 * @createDate: 2022/11/9 14:18
 * @version: 1.0
 */
public class SynchronizedMethod{


    public static void main(String[] args) {

        SynchronizedMethod t=new SynchronizedMethod();
        new Thread(new Runnable() {
            @Override
            public void run() {
                t.test("线程1");
            }
        }).start();


        SynchronizedMethod t1=new SynchronizedMethod();
        new Thread(new Runnable() {
            @Override
            public void run() {
                t1.test("线程2");
            }
        }).start();


    }


    /**
     * synchronized 同步方法，对于普通方法，锁的拥有者是当前实例，不同实例并不互相影响
     * @param name
     */
    public synchronized void test(String name){
        System.out.println(name+"正在运行ing");
        try {
            Thread.sleep(2000);
        }catch (Exception e){
        }
        System.out.println(name+"运行结束end");
    }
}

我们可以从结果可以看出，线程没有阻塞运行，因此对于普通方法，如果是不同的对象实例锁是不起作用的

1.3.2 synchronized同步代码块

package class02.Synchronized;

/**
 * @description: 同步代码块
 * @author: shu
 * @createDate: 2022/11/9 14:28
 * @version: 1.0
 */
public class SynchronizedCode {
    public static void main(String[] args) {

        SynchronizedCode t=new SynchronizedCode();
        new Thread(new Runnable() {
            @Override
            public void run() {
                t.test("线程1");
            }
        }).start();


        SynchronizedCode t1=new SynchronizedCode();
        new Thread(new Runnable() {
            @Override
            public void run() {
                t1.test("线程2");
            }
        }).start();


    }


    /**
     * synchronized 同步代码块
     * @param name
     */
    public synchronized void test(String name){
        Object o=new Object();
        synchronized(o.getClass()) {
            System.out.println(name + "正在运行");
            try {
                Thread.sleep(2000);
            } catch (Exception e) {
            }
            System.out.println(name + "运行结束");
        }
    }
}

我们看出，线程阻塞运行，依次获取锁对象

1.3.3 synchronized静态方法

package class02.Synchronized;

/**
 * @description: 静态同步代码
 * @author: shu
 * @createDate: 2022/11/9 14:34
 * @version: 1.0
 */
public class SynchronizedStaticMethods {
    public static void main(String[] args) {

        new Thread(new Runnable() {
            @Override
            public void run() {
                SynchronizedStaticMethods.test("线程1");
            }
        }).start();

        
        new Thread(new Runnable() {
            @Override
            public void run() {
                SynchronizedStaticMethods.test("线程2");
            }
        }).start();


    }


    /**
     * synchronized 对于静态同步方法，锁的是当前类的Class对象。
     * @param name
     */
    public static synchronized void test(String name){
        System.out.println(name+"正在运行");
        try {
            Thread.sleep(2000);
        }catch (Exception e){
        }
        System.out.println(name+"运行结束");
    }
}

我们可以看出，当前线程也是阻塞运行的

1.3.4 总结

synchronized方法和synchronized同步块有什么区别呢？

synchronized方法是一种粗粒度的并发控制，某一时刻只能有一个线程执行该synchronized方法。
synchronized代码块是一种细粒度的并发控制，处于synchronized块之外的其他代码是可以被多个线程并发访问的。

     public class TwoPlus{
     
         private int sum1 = 0;
         private int sum2 = 0;
         private Integer sum1Lock = new Integer(1); // 同步锁一
         private Integer sum2Lock = new Integer(2); // 同步锁二
     
         public void plus(int val1, int val2){
            //同步块1
             synchronized(this.sum1Lock){
                 this.sum1 += val1;
             }
            //同步块2
            synchronized(this.sum2Lock){
                 this.sum2 += val2;
             }
         }
     }

二 Java对象结构与内置锁

2.1 Java对象结构

Java对象（Object实例）结构包括三部分：对象头、对象体和对齐字节
Java对象结构.png

2.2.1 对象头

说明

Mark Word（标记字）字段主要用来表示对象的线程锁状态，另外还可以用来配合GC存放该对象的hashCode。
Class Pointer（类对象指针）字段是一个指向方法区中Class信息的指针，意味着该对象可随时知道自己是哪个Class的实例。
Array Length（数组长度）字段占用32位（在32位JVM中）字节，这是可选的，只有当本对象是一个数组对象时才会有这个部分。

2.2.2 对象体

对象体包含对象的实例变量（成员变量），用于成员属性值，包括父类的成员属性值。这部分内存按4字节对齐。

说明

对象体用于保存对象属性值，是对象的主体部分，占用的内存空间大小取决于对象的属性数量和类型。

2.2.3 对齐字节

对齐字节也叫作填充对齐，其作用是用来保证Java对象所占内存字节数为8的倍数HotSpot VM的内存管理要求对象起始地址必须是8字节的整数倍。
对象头本身是8的倍数，当对象的实例变量数据不是8的倍数时，便需要填充数据来保证8字节的对齐。

说明

对齐字节并不是必然存在的，也没有特别的含义，它仅仅起着占位符的作用。当对象实例数据部分没有对齐（8字节的整数倍）时，就需要通过对齐填充来补全。

2.2.4 注意点

Mark Word、Class Pointer、Array Length等字段的长度都与JVM的位数有关。
Mark Word的长度为JVM的一个Word（字）大小，也就是说32位JVM的Mark Word为32位，64位JVM的Mark Word为64位。
Class Pointer（类对象指针）字段的长度也为JVM的一个Word（字）大小，即32位JVM的Mark Word为32位，64位JVM的Mark Word为64位。
对于对象指针而言，如果JVM中的对象数量过多，使用64位的指针将浪费大量内存，通过简单统计，64位JVM将会比32位JVM多耗费50%的内存。
为了节约内存可以使用选项+UseCompressedOops开启指针压缩。UseCompressedOops中的Oop为Ordinary object pointer（普通对象指针）的缩写。

手动开启Oop对象指针压缩

java -XX:+UseCompressedOops mainclass

手动关闭Oop对象指针压缩

java -XX:-UseCompressedOops mainclass

Array Length字段的长度也随着JVM架构的不同而不同：在32位JVM上，长度为32位；在64位JVM上，长度为64位。64位JVM如果开启了Oop对象的指针压缩，Array Length字段的长度也将由64位压缩至32位。

2.2 Mark Word 详细介绍

Java内置锁涉及很多重要信息，这些都存放在对象结构中，并且存放于对象头的Mark Word字段中。

32 位Mark Word结构

64 位Mark Word结构

lock：锁状态标志位

lock：锁状态标记位，占两个二进制位，由于希望用尽可能少的二进制位表示尽可能多的信息，因此设置了lock标记。该标记的值不同，整个Mark Word表示的含义就不同。

biased_lock：对象是否启用偏向锁标记

biased_lock：对象是否启用偏向锁标记，只占1个二进制位。为1时表示对象启用偏向锁，为0时表示对象没有偏向锁。

组合

age : Java对象分代年龄

age：4位的Java对象分代年龄。在GC中，对象在Survivor区复制一次，年龄就增加1。当对象达到设定的阈值时，将会晋升到老年代。默认情况下，并行GC的年龄阈值为15，并发GC的年龄阈值为6。由于age只有4位，因此最大值为15，这就是-XX:MaxTenuringThreshold选项最大值为15的原因。

identity_hashcode：对象标识HashCode（哈希码）

identity_hashcode：31位的对象标识HashCode（哈希码）采用延迟加载技术，当调用Object.hashCode()方法或者System.identityHashCode()方法计算对象的HashCode后，其结果将被写到该对象头中。当对象被锁定时，该值会移动到Monitor（监视器）中。

thread：54位的线程ID值为持有偏向锁的线程ID

epoch：偏向时间戳。

ptr_to_lock_record：占62位，在轻量级锁的状态下指向栈帧中锁记录的指针。

ptr_to_heavyweight_monitor：占62位，在重量级锁的状态下指向对象监视器的指针。

2.3 JOL工具查看对象的布局

依赖包

<!--Java Object Layout -->
<dependency>
  <groupId>org.openjdk.jol</groupId>
  <artifactId>jol-core</artifactId>
  <version>0.11</version>
</dependency>

工具类

package com.shu;

import java.io.*;

/**
 * byte数组工具类实现byte[]与文件之间的相互转换
 */
public class ByteUtil {
    /**
     * 字节数据转字符串专用集合
     */
    private static final char[] HEX_CHAR =
            {'0', '1', '2', '3', '4', '5', '6',
                    '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};

    /**
     * 字节数据转十六进制字符串
     *
     * @param data 输入数据
     * @return 十六进制内容
     */
    public static String byteArrayToString(byte[] data) {
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i < data.length; i++) {
            // 取出字节的高四位 作为索引得到相应的十六进制标识符 注意无符号右移
            stringBuilder.append(HEX_CHAR[(data[i] & 0xf0) >>> 4]);
            // 取出字节的低四位 作为索引得到相应的十六进制标识符
            stringBuilder.append(HEX_CHAR[(data[i] & 0x0f)]);
            if (i < data.length - 1) {
                stringBuilder.append(' ');
            }
        }
        return stringBuilder.toString();
    }

    /**
     * byte转换hex函数
     *
     * @param byteArray
     * @return
     */
    public static String byteToHex(byte[] byteArray) {
        StringBuffer strBuff = new StringBuffer();
        for (int i = 0; i < byteArray.length; i++) {
            if (Integer.toHexString(0xFF & byteArray[i]).length() == 1) {
                strBuff.append("0").append(
                        Integer.toHexString(0xFF & byteArray[i]));
            } else {
                strBuff.append(Integer.toHexString(0xFF & byteArray[i]));
            }
            strBuff.append(" ");
        }
        return strBuff.toString();
    }

    /**
     * 以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件。
     */
    public static byte[] readFileByBytes(String fileName) {
        File file = new File(fileName);
        InputStream in = null;
        byte[] txt = new byte[(int) file.length()];
        try {
            // 一次读一个字节
            in = new FileInputStream(file);
            int tempByte;
            int i = 0;
            while ((tempByte = in.read()) != -1) {
                txt[i] = (byte) tempByte;
                i++;
            }
            in.close();
            return txt;
        } catch (IOException e) {
            e.printStackTrace();
            return txt;
        }
    }

    /**
     * 获得指定文件的byte数组
     */
    public static byte[] getBytes(String filePath) {
        byte[] buffer = null;
        try {
            File file = new File(filePath);
            FileInputStream fis = new FileInputStream(file);
            ByteArrayOutputStream bos = new ByteArrayOutputStream(1000);
            byte[] b = new byte[1000];
            int n;
            while ((n = fis.read(b)) != -1) {
                bos.write(b, 0, n);
            }
            fis.close();
            bos.close();
            buffer = bos.toByteArray();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return buffer;
    }

    /**
     * 根据byte数组，生成文件
     */
    public static void saveFile(byte[] bfile, String filePath) {
        BufferedOutputStream bos = null;
        FileOutputStream fos = null;
        File file = null;
        try {
            File dir = new File(filePath);
            //判断文件目录是否存在
            if (!dir.exists() && dir.isDirectory()) {
                dir.mkdirs();
            }
            file = new File(filePath);
            fos = new FileOutputStream(file);
            bos = new BufferedOutputStream(fos);
            bos.write(bfile);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (bos != null) {
                try {
                    bos.close();
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
            }
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
            }
        }
    }


    public static final int UNICODE_LEN = 2;


    /**
     * int转换为小端byte[]（高位放在高地址中）
     *
     * @param iValue
     * @return
     */
    public static byte[] int2Bytes_LE(int iValue) {
        byte[] rst = new byte[4];
        // 先写int的最后一个字节
        rst[0] = (byte) (iValue & 0xFF);
        // int 倒数第二个字节
        rst[1] = (byte) ((iValue & 0xFF00) >> 8);
        // int 倒数第三个字节
        rst[2] = (byte) ((iValue & 0xFF0000) >> 16);
        // int 第一个字节
        rst[3] = (byte) ((iValue & 0xFF000000) >> 24);
        return rst;
    }

    /**
     * long转成字节
     *
     * @param num
     * @return
     */
    public static byte[] long2bytes(long num) {
        byte[] b = new byte[8];
        for (int i = 0; i < 8; i++) {
            b[i] = (byte) (num >>> (56 - (i * 8)));
        }
        return b;
    }

    /**
     * bytes2bytes 大端转小端
     *
     * @param input
     * @return
     */
    public static byte[] bytes2bytes_LE(byte[] input) {
        int len = input.length;
        byte[] b = new byte[len];
        for (int i = 0; i < len; i++) {
            b[i] = input[len - 1 - i];
        }
        return b;
    }

    /**
     * long转成字节 小端
     *
     * @param num
     * @return
     */
    public static byte[] long2bytes_LE(long num) {
        byte[] b = long2bytes(num);
        return bytes2bytes_LE(b);
    }

    /**
     * 转成long
     *
     * @param b 字节
     * @return
     */
    public static long bytes2long(byte[] b) {
        long temp = 0;
        long res = 0;
        for (int i = 0; i < 8; i++) {
            res <<= 8;
            temp = b[i] & 0xff;
            res |= temp;
        }
        return res;
    }

    public static int bytes2int(byte[] bytes) {
        int num = bytes[0] & 0xFF;
        num |= ((bytes[1] << 8) & 0xFF00);
        num |= ((bytes[2] << 16) & 0xFF0000);
        num |= ((bytes[3] << 24) & 0xFF000000);
        return num;
    }

    /**
     * 转换String为byte[]
     *
     * @param str
     * @return
     */
    public static byte[] string2Bytes_LE(String str) {
        if (str == null) {
            return null;
        }
        char[] chars = str.toCharArray();

        byte[] rst = chars2Bytes_LE(chars);

        return rst;
    }


    /**
     * 转换字符数组为定长byte[]
     *
     * @param chars 字符数组
     * @return 若指定的定长不足返回null, 否则返回byte数组
     */
    public static byte[] chars2Bytes_LE(char[] chars) {
        if (chars == null)
            return null;

        int iCharCount = chars.length;
        byte[] rst = new byte[iCharCount * UNICODE_LEN];
        int i = 0;
        for (i = 0; i < iCharCount; i++) {
            rst[i * 2] = (byte) (chars[i] & 0xFF);
            rst[i * 2 + 1] = (byte) ((chars[i] & 0xFF00) >> 8);
        }

        return rst;
    }


    /**
     * 转换byte数组为int（小端）
     *
     * @return
     * @note 数组长度至少为4，按小端方式转换,即传入的bytes是小端的，按这个规律组织成int
     */
    public static int bytes2Int_LE(byte[] bytes) {
        if (bytes.length < 4)
            return -1;
        int iRst = (bytes[0] & 0xFF);
        iRst |= (bytes[1] & 0xFF) << 8;
        iRst |= (bytes[2] & 0xFF) << 16;
        iRst |= (bytes[3] & 0xFF) << 24;

        return iRst;
    }


    /**
     * 转换byte数组为int（大端）
     *
     * @return
     * @note 数组长度至少为4，按小端方式转换，即传入的bytes是大端的，按这个规律组织成int
     */
    public static int bytes2Int_BE(byte[] bytes) {
        if (bytes.length < 4)
            return -1;
        int iRst = (bytes[0] << 24) & 0xFF;
        iRst |= (bytes[1] << 16) & 0xFF;
        iRst |= (bytes[2] << 8) & 0xFF;
        iRst |= bytes[3] & 0xFF;

        return iRst;
    }


    /**
     * 转换byte数组为Char（小端）
     *
     * @return
     * @note 数组长度至少为2，按小端方式转换
     */
    public static char Bytes2Char_LE(byte[] bytes) {
        if (bytes.length < 2)
            return (char) -1;
        int iRst = (bytes[0] & 0xFF);
        iRst |= (bytes[1] & 0xFF) << 8;

        return (char) iRst;
    }


    /**
     * 转换byte数组为char（大端）
     *
     * @return
     * @note 数组长度至少为2，按小端方式转换
     */
    public static char Bytes2Char_BE(byte[] bytes) {
        if (bytes.length < 2)
            return (char) -1;
        int iRst = (bytes[0] << 8) & 0xFF;
        iRst |= bytes[1] & 0xFF;

        return (char) iRst;
    }

    public static String byte2BinaryString(byte nByte) {
        StringBuilder nStr = new StringBuilder();
        for (int i = 7; i >= 0; i--) {
            int j = (int) nByte & (int) (Math.pow(2, (double) i));
            if (j > 0) {
                nStr.append("1");
            } else {
                nStr.append("0");
            }
        }
        return nStr.toString();
    }

}

对象编写

package com.shu;

/**
 * @description:
 * @author: shu
 * @createDate: 2022/11/10 9:31
 * @version: 1.0
 */
import org.openjdk.jol.info.ClassLayout;


public class ObjectLock
{
    private Long amount = 0L; //整型字段占用4字节

    public void increase()
    {
        synchronized (this)
        {
            amount++;
        }
    }

    /**
     * 输出十六进制、小端模式的hashCode
     */
    public String hexHash()
    {
        //对象的原始 hashCode，Java默认为大端模式
        int hashCode = this.hashCode();

        //转成小端模式的字节数组
        byte[] hashCode_LE = ByteUtil.int2Bytes_LE(hashCode);

        //转成十六进制形式的字符串
        return ByteUtil.byteToHex(hashCode_LE);
    }

    /**
     * 输出二进制、小端模式的hashCode
     */
    public String binaryHash()
    {
        //对象的原始 hashCode，Java默认为大端模式
        int hashCode = this.hashCode();

        //转成小端模式的字节数组
        byte[] hashCode_LE = ByteUtil.int2Bytes_LE(hashCode);

        StringBuffer buffer=new StringBuffer();
        for (byte b:hashCode_LE)
        {
            //转成二进制形式的字符串
            buffer.append( ByteUtil.byte2BinaryString(b));
            buffer.append(" ");
        }
        return buffer.toString();
    }

    /**
     * 输出十六进制、小端模式的ThreadId
     */
    public String hexThreadId()
    {
        //当前线程的 threadID，Java默认为大端模式
        long threadID = Thread.currentThread().getId();

        //转成小端模式的字节数组
        byte[] threadID_LE = ByteUtil.long2bytes_LE(threadID);

        //转成十六进制形式的字符串
        return ByteUtil.byteToHex(threadID_LE);
    }

    /**
     * 输出二进制、小端模式的ThreadId
     */
    public String binaryThreadId()
    {
        //当前线程的 threadID，Java默认为大端模式
        long threadID = Thread.currentThread().getId();
        //转成小端模式的字节数组
        byte[] threadID_LE = ByteUtil.long2bytes_LE(threadID);

        StringBuffer buffer=new StringBuffer();
        for (byte b:threadID_LE)
        {
            //转成二进制形式的字符串
            buffer.append( ByteUtil.byte2BinaryString(b));
            buffer.append(" ");
        }
        return buffer.toString();
    }

    public void printSelf()
    {
        // 输出十六进制、小端模式的hashCode
        System.out.println("lock hexHash= " + hexHash());

        // 输出二进制、小端模式的hashCode
        System.out.println("lock binaryHash= " + binaryHash());

        //通过JOL工具获取this的对象布局
        String printable = ClassLayout.parseInstance(this).toPrintable();

        //输出对象布局
        System.out.println("lock = " + printable);
    }
    // 省略其他
}

测试

package com.shu;

import org.openjdk.jol.vm.VM;

/**
 * @description:
 * @author: shu
 * @createDate: 2022/11/10 9:43
 * @version: 1.0
 */
public class InnerLockTest {
    public static void main(String[] args) {
        System.out.println(VM.current().details());
        ObjectLock objectLock=new ObjectLock();
        System.out.println("object status");
        objectLock.printSelf();
    }
}

当前JVM的运行环境为64位虚拟机。
运行结果中输出了ObjectLock的对象布局，所输出的ObjectLock对象为16字节，其中对象头（Object Header）占12字节，剩下的4字节由amount属性（字段）占用。
由于16字节为8字节的倍数，因此没有对齐填充字节（JVM规定对象头部分必须是8字节的倍数，否则需要对齐填充）。
对象一旦生成了哈希码，它就无法进入偏向锁状态。也就是说，只要一个对象已经计算过哈希码，它就无法进入偏向锁状态。
当一个对象当前正处于偏向锁状态，并且需要计算其哈希码的话，它的偏向锁会被撤销，并且锁会膨胀为重量级锁。

补充

大端序：大端模式是指数据的高字节保存在内存的低地址中，而数据的低字节保存在内存的高地址中。大端存放模式有点类似于把数据当作字符串顺序处理：地址由小向大增加，而数据从高位往低位放。
小端序：小端模式是指数据的高字节保存在内存的高地址中，而数据的低字节保存在内存的低地址中，这种存储模式将地址的高低和数据位权有效地结合起来，高地址部分权值高，低地址部分权值低，此模式和日常的数字计算在方向上是一致的。