Synchronized原理Java对象头当对象头最后三位为001时，处于无锁状态当对象头最后三位为101时，处于偏

Java对象头

当对象头最后三位为001时，处于无锁状态
当对象头最后三位为101时，处于偏向锁状态
当对象头最后三位为000时，处于轻量锁状态
当对象头最后三位为010时，处于重量锁状态

锁的升级流程

轻量级锁

轻量级锁在线程交替进行的情况下相对于重量级锁效率有所提高。这是因为在申请轻量级锁时不会进行系统调用，减少了用户态到内核态的切换。

轻量级锁加锁过程：

创建锁记录(Lock Record)对象，每个线程的栈帧都会包含一个锁记录对象，内部可以存储锁定对象的Mark Word信息

让锁记录中Object reference指向锁对象，并尝试用cas替换Object中的Mark Word，将Mark Word的值存入锁记录中

如果cas替换成功，对象头中存储了锁记录和状态00，表示该线程给对象加锁，此时如图

如果cas失败，此时有两种情况
1. 一种是已经有线程对obj对象进行了加锁，证明有竞争发生，此时会发生锁膨胀
2. 如果是自己执行了synchronized锁重入，那么线程中将会再添加一条Lock record作为重入的计数

锁膨胀

代码验证轻量级锁

在这里准备打印出对象头信息来观察对象头的bit变化，使用jol查看对象头

<dependency>
    <groupId>org.openjdk.jol</groupId>
    <artifactId>jol-core</artifactId>
    <version>0.14</version>
</dependency>

由于jol打印的对象头不太好观察，这里写了一个方法进行解析

public static String parseHeader(String header) {
    int index = header.indexOf('\n');
    int i2 = header.indexOf('\n', index + 1);
    header = header.substring(i2+1);
    int toFRBracket = header.indexOf(')');
    int toValBracket = header.indexOf('(',toFRBracket+1);
    int toValEndBracket = header.indexOf(')',toValBracket);

    String first4bit = header.substring(toValBracket+1,toValEndBracket);
    int endline = header.indexOf('\n');
    header = header.substring(endline+1);
    String second4bit = header.substring(toValBracket+1,toValEndBracket);

    String[] firsts = first4bit.split(" ");
    String[] seconds = second4bit.split(" ");
    StringBuilder res = new StringBuilder();
    StringBuilder out = new StringBuilder();
    for (int i = seconds.length-1; i >= 0; i--) {
        res.append(seconds[i]).append(" ");
        out.append(seconds[i]);
    }
    for (int i = firsts.length-1; i >= 0; i--) {
        res.append(firsts[i]).append(" ");
        out.append(firsts[i]);
    }

    String unused = out.substring(0, 25);
    String hashcode = out.substring(25, 56);
    String unused2 = out.substring(56, 57);
    String age = out.substring(57, 61);
    String bias = out.substring(61, 62);
    String sort = out.substring(62, 64);
    System.out.println("unused_25bit             " +
                        " hashcode_31bit                  " +
                        "  " + "age  " + "b " + "st ");
    System.out.println(unused + " " + hashcode + " " + unused2 + " " + age + " " + bias + " " +sort);

    return res.toString();
}

我们先不谈论偏向锁，可以使用虚拟机参数-XX:-UseBiasedLocking关闭偏向锁。

public class Synchronized {

    public static void main(String[] args) throws InterruptedException {
        ThreadTest test = new ThreadTest();
        Thread t1 = new Thread(test,"first thread");
        Thread t2 = new Thread(test,"second thread");
        t1.start();
        t2.start();
    }
    
    static class ThreadTest implements Runnable{

        int count = 0;

        @Override
        public void run() {
            synchronized (this) {
                System.out.println("thread: "+Thread.currentThread().getName());
                System.out.println(parseHeader(ClassLayout.parseInstance(this).toPrintable()));
                System.out.println();
                count++;
            }
        }
    }
}