从对象头的两个字宽解析对象的4种状态，锁信息，分代信息和分析锁升级的过程

最新推荐文章于 2021-02-13 14:50:15 发布

置顶头发不会掉

最新推荐文章于 2021-02-13 14:50:15 发布

阅读量364

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/weixin_42765975/article/details/104282850

版权

Java 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

看图说话
在这里插入图片描述

了解CAS,Sychrine关键字，AQS参考文章

什么是元数据：

解析数据的数据叫元数据，Java里面有4种类型的元数据，类，接口，枚举，注解，对象的元数据，就是处于方法区的类型信息（静态变量，成员变量名，类函数名，类函数代码，函数返回值等）。但是一定要理解元数据不是class对象，class对象是类加载的最终产品，class对象是存在堆区的。
还有一点元空间不是存储class对象的，****元空间和永久代是一种jvm方法区的实现，永久代更加不是老年代(永久代permanent也有人叫持久代)。元空间的本质和永久代类似，都是对JVM规范中方法区的实现。不过元空间与永久代之间最大的区别在于：元空间并不在虚拟机中，而是使用本地内存。因此，默认情况下，元空间的大小仅受本地内存限制，但可以通过以下参数来指定元空间的大小。现在版本的虚拟机用元区间取代了原来的永久代。

什么是CAS指令：

CAS （Compare And Swap，比较交换）指令是一个CPU层级的原子性操作指令，CAS归功于硬件指令集的发展，乐观锁，轻量级的锁就是用这些指令来实现的
CAS的全称Compare And Swap，直译就是比较和交换，一种无锁原子算法。

与锁相比，使用CAS会使程序看起来更加复杂一些，但由于其非阻塞的，它对死锁问题天生免疫，并且，线程间的相互影响也非常小。更为重要的是，使用无锁的方式完全没有锁竞争带来的系统开销，也没有线程间频繁调度带来的开销，因此，它要比基于锁的方式拥有更优越的性能

什么是AQS(AbstractQueueSychronizer)

AQS翻译过来就是抽象的队列同步器，基于cas的锁同步框架，这个类是抽象的，常用的ReentrantLock类就是继承他来实现的，还有很多处理高并发的框架就是用它来实现的，不用sychronize关键字，了解AQS原理就是了解cas指令的原理，且加入了公平锁和非公平锁概念

volitate关键字实现变量在线程工作区和主存之间可见性，和禁止指令重排序

volitae两大功能：1.可见性2.，禁止重排序

可见性
在一个线程读一个线程写的情况下，写线程对volitate变量进行写后不仅改变工作区的变量，还会立刻刷到主存中。读线程进行读数据时不会直接用工作区的数据会重新到主存里面再读最新的数据，这个就保证了线程之间的可见性。。
但是在两个线程同时写操作时就不好办了，要用synchronied关键字。
在这里插入图片描述
volitate更多参考

首先来看看什么是指令重排序
int a=1;
int b=2;
int c=a+b;

a=1;b=2这两个指令的顺序是不确定的；可以先是a=1再b=2,也可以是先b=2再a=1;这就是指令重排序，在单线程下这种效果不明显，但是在多线程下这种重排序造成的不确定性就很明显（但是c=a+b这个指令一定是在a=1和b=2这两个指令之后的）

加了volitate之后就会禁止这种重排序现象出现，b=2一定在a=1之后；
看代码：

public class ReorderDemo1 {
 
 
    private int count=2;
    private boolean flag=false;
    private volatile boolean sync=false;
 
    public void write1()  {
        count=10;
        flag=true;//没有volatile修饰，实际执行顺序，有可能是flag=true先执行
    }
 
    public void read1()  {
        if(flag){
            System.out.print(count); // 有些jvm会打印10，有些jvm会打印2，这是不确定的
        }
    }
 
 
    public void write2() {
        count=10;
        sync=true;// 由于出现了volatile，所以这里禁止重排序
    }
 
    public void read2()  {
        if(sync){
            System.out.print(count); // 在jdk5之后，由volatile保证，count的值总是等于10
        }
 
    }
 
 
 
 
    public static void main(String[] args) {
 
        for(int i=0;i<300;i++){
            //实例化变量
            ReorderDemo1 reorderDemo1=new ReorderDemo1();
            //写线程
            Thread t1=new Thread(()-> { reorderDemo1.write1();});
            //读线程
            Thread t2=new Thread(()-> { reorderDemo1.read1(); });
 
             t1.start();
             t2.start();
 
        }
 
 
 
 
    }
 
 
 
 
}

main方法一：：

    private int count=2;
    private boolean flag=false;
    private volatile boolean sync=false;
 
    public void write1()  {
        count=10;
        flag=true;//没有volatile修饰，实际执行顺序，有可能是flag=true先执行
    }
 
    public void read1()  {
        if(flag){
            System.out.print(count); // 有些jvm会打印10，有些jvm会打印2，这是不确定的
        }
    }

由于指令会重排序，当线程一里面执行write1方法的flag=true的时候，同时线程2执行了read1 方法，那么count的值是不确定的，可能是10，也可能是2，

main方法二：：

    private int count=2;
    private boolean flag=false;
    private volatile boolean sync=false;
    
     public void write2() {
     count=10;
     sync=true;// 由于出现了volatile，所以这里禁止重排序
    }
 
    public void read2()  {
        if(sync){
            System.out.print(count); // 在jdk5之后，由volatile保证，count的值总是等于10
        }
 
    }

注意这里的sync变量是加了volatile修饰，意味着禁止了重排序，第一个线程调用write2方法时候，同样第二个线程在调用read2方法时候，如果sync=true，那么count的值一定是10

Lock接口底层实现不是通过synchronized实现的

lock的实现完全是由java写的，和操作系统或者是JVM虚拟机没有任何关系。整体来看Lock主要是通过两个东西来实现的分别是CAS和ASQ(AbstractQueuedSynchronizer)。通过加锁和解锁的过程来分析锁的实现。RentranLock类可重入锁类是他常用的实现类，加入了公平锁，非公平锁等概念。
ReentrantLock的实现机制是靠其内部类Sync，而这个类是AbstractQueuedSynchronizer（AQS）的子类。这个类的主要功能是通过管理一个双向同步队列（FIFO）实现同步状态的管理，实现多线程对同步状态的访问安全。在同步队列种存储的数据结构是一个个的节点Node，其中包含了跟双向链表类似的前向节点和后续节点的引用，以及后续等待的节点引用以及被构造入的线程。在之后要讲的等待队列中的节点与这个是相同的定义。

在这里插入图片描述

解析上图：：：
对象内存布局：对象头，实例数据，字节填充（因为JVM要求java的对象占的内存大小应该是8bit的倍数，所以后面有几个字节用于把对象的大小补齐至8bit的倍数，没有特别的功能。）
对象头一般包括2个字宽，markWork一个，classMetaData(存本对象在方法区的类对象指针)，如果是数组对象则还有一个字宽存的是数组的长度
分代年龄字段是由GC进程进行，出生对象字段为0，经过一次GC就加一，依次增加，从新生代（eden区,survivor区from， to ）到老年代（为15时就进入老年代）
epoch:引入一个概念 epoch, 其本质是一个时间戳，代表了偏向锁的有效性

对象的四个状态（无锁，偏向锁，轻量级锁，重量级锁）的演化过程：
1.该开始对象创立没被当作同步锁时是一个普通对象，markwork字宽存对象的hashCode,分代年龄，锁标志位是01，是否偏向锁那一位是0。

2，当对象被当做同步锁并有一个线程A抢到了锁时，锁标志位还是01，但是否偏向锁那一位改成1，前23bit记录抢到锁的线程id，表示进入偏向锁状态。

3，当线程A再次试图来获得锁时，JVM发现同步锁对象的标志位是01，是否偏向锁是1，也就是偏向状态，Mark Word中记录的线程id就是线程A自己的id，表示线程A已经获得了这个偏向锁，可以执行同步锁的代码。

4，当线程B试图获得这个锁时，JVM发现同步锁处于偏向状态，但是Mark Word中的线程id记录的不是B，那么线程B会先用CAS操作试图获得锁，这里的获得锁操作是有可能成功的，因为线程A一般不会自动释放偏向锁。如果抢锁成功，就把Mark Word里的线程id改为线程B的id，代表线程B获得了这个偏向锁，可以执行同步锁代码。如果抢锁失败，则继续执行步骤5。

5，偏向锁状态抢锁失败，代表当前锁有一定的竞争，偏向锁将升级为轻量级锁。JVM会在当前线程的线程栈中开辟一块单独的空间，里面保存指向对象锁Mark Word的指针，同时在对象锁Mark Word中保存指向这片空间的指针。上述两个保存操作都是CAS操作，如果保存成功，代表线程抢到了同步锁，就把Mark Word中的锁标志位改成00，可以执行同步锁代码。如果保存失败，表示抢锁失败，竞争太激烈，继续执行步骤6。

6，轻量级锁抢锁失败，JVM会使用自旋锁，自旋锁不是一个锁状态，只是代表不断的重试，尝试抢锁。从JDK1.7开始，自旋锁默认启用，**自旋次数由JVM决定。**如果抢锁成功则执行同步锁代码，如果失败则继续执行步骤7。

7，自旋锁重试之后如果抢锁依然失败，同步锁会升级至重量级锁，锁标志位改为10。在这个状态下，未抢到锁的线程都会被阻塞。

8.进入重量级锁时，是依靠monitor类来实现的。markWork存储指向了monitor监视类对象的指针，即上图重量级锁指针，由他来控制锁
9.后期补充：在标识位为11时表示这个对象被垃圾回收线程GC持有，在一些垃圾回收器有stop all the word的说法，就是垃圾回收是其他的全部线程要阻塞。

详细参考1
参考2

头发不会掉

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
从对象头的两个字宽解析对象的4种状态，锁信息，分代信息和分析锁升级的过程

什么是元数据：解析数据的数据叫元数据，Java里面有4种类型的元数据，类，接口，枚举，注解，对象的元数据，就是处于方法区的类型对象信息什么是CAS指令：CAS （Compare And Swap）指令是一个CPU层级的原子性操作指令，Lock接口底层实现不是通过synchronized实现的lock的实现完全是由java写的，和操作系统或者是JVM虚拟机没有任何关系。整体来看Lock主...
复制链接

扫一扫