synchronized锁升级

为什么会有锁升级：

原因就是具体问题具体分析，每一个锁状态来对应不同的情况状态，使之资源的开销最小，效率最高。

四种锁状态：

1.无锁

2.偏向锁

3.轻量级锁

4.重量级锁

状态描述：

无锁：即线程没有加锁，为无锁状态

偏向锁：只有单个线程加锁时，此时没有锁竞争

轻量级锁：一个或多个线程通过CAS的方式自选竞争锁资源，临界区运行时间较短的情况

重量级锁：多个线程争夺锁资源，临界区运行时间较长，此时会调用内核的锁资源，没有争抢到锁资源的线程直接放入阻塞队列，开销较大。

锁状态升级可视化：

使用maven项目，引用依赖

<!-- https://mvnrepository.com/artifact/org.openjdk.jol/jol-core -->
<dependency>
    <groupId>org.openjdk.jol</groupId>
    <artifactId>jol-core</artifactId>
    <version>0.9</version>
</dependency>

---

代码：

public class mySynUpdate {
    public static void main(String[] args) {
        mySynUpdate mySynUpdate = new mySynUpdate();
        System.out.println(ClassLayout.parseInstance(mySynUpdate).toPrintable());
    }
}

---

想要看懂这个输出结果，我们需要知道一些其他知识:

对象的组成：对象头 + 实例部分 + 对齐部分

对象头：Mark Word + 类型指针

Mark Word示意图：

故Mark Word存储的就是该目标对象的锁状态信息，从图中我们可以看到，上面各个栏的bit位加起来刚好是64位，也就是8个字节，回到上面那幅图

---

无锁状态：

---

偏向锁状态：

public class mySynUpdate {
    static private Object loker = new Object();

    static class myTask implements Runnable{
        @Override
        public void run() {
            synchronized (loker){
                String test="";
                for (int i = 0; i < 1000; i++) {
                    test += "2";
                }
                System.out.println(ClassLayout.parseInstance(new myTask()).toPrintable());
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        mySynUpdate m = new mySynUpdate();
        //对象由三部分组成:对象头 实例数据  对其填充
        //Object 对象头:Mark Word + 类型指针
        //Mark Word 占8个字节 --- 64位  记录锁状态
        //此时没有实例数据 所以前两行为Mark Word----8个字节   第三行为类型指针:被压缩了----4个字节  最后一行为对其填充:总大小必须是8的倍数

        //无锁时状态位:偏向锁0  锁状态位01  001
        //一个线程加锁时:转换成偏向锁  偏向锁1 锁状态位01  101
        myTask mt = new myTask();
        new Thread(mt).start();
    }
}

此时我们发现：咦，不是已经加锁了吗  状态码为啥还是001---无锁状态：

原来，偏向锁会延迟启动，默认是程序启动后4s，故我们可以让执行内容休眠4秒再看内部

---

static private Object loker = new Object();

    static class myTask implements Runnable{
        @Override
        public void run() {
            synchronized (loker){
                String test="";
                for (int i = 0; i < 1000; i++) {
                    test += "2";
                }
                try {
                    Thread.sleep(4000);
                    System.out.println(ClassLayout.parseInstance(new myTask()).toPrintable());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

此时的锁状态就从001变成101了----->偏向锁

轻量级锁：---->重量级锁  qwq

   static Object loker = new Object();

    static class myTask implements Runnable{
        @Override
        public void run() {
            synchronized (loker){
                String test="";
                for (int i = 0; i < 1000; i++) {
                    test += "2";
                }
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        myTask mt = new myTask();
        myTask mt1 = new myTask();
        System.out.println(ClassLayout.parseInstance(mt).toPrintable());
        Thread t1= new Thread(mt);
        t1.start();
        Thread t2 = new Thread(mt1);
        t2.start();

        t1.join();
        t2.join();
        System.out.println("**********轻量级锁*********");
        System.out.println(ClassLayout.parseInstance(loker).toPrintable());
    }

遗憾的是，结果并不像我们预期那样，锁状态位变成了10---->重量级锁，这里的话作者也不知道为啥，也就两个线程争夺锁资源哇，为啥就变成重量级锁了

欢迎大家补充说明~