关于锁升级，经历过hashcode后的结果

已于 2022-05-12 10:30:20 修改
阅读量1.7k 收藏 8
点赞数
分类专栏： JVM--JMM 文章标签： jvm
于 2020-10-19 14:52:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011433316/article/details/109158233
版权

@TOC

一、锁升级问题

package com.woniuxy.synchronizedupgrade;

import org.openjdk.jol.info.ClassLayout;

class C{
    int a=0;
    int d=0;
    static String b="123";
}
/**
 * Auther: mayuhang  <br/>
 * Date: 2020/7/8:22:21  <br/>
 * Description:
 */
public class  ObjectUpGrade {
    public static void main(String[] args) throws InterruptedException {
        //放在延时前，JVM未开启偏向锁，创建的c1对象，会出现一个问题，它会直接从无锁升级为轻量级锁
        C c1 = new C();
        System.out.println("启动后，c1:无锁" + ClassLayout.parseInstance(c1).toPrintable());
        //预留4s,等待开启偏向锁功能 或者使用命令
        //vm参数： -XX:+UseBiasedLocking开启偏向锁
        //-XX:BiasedLockingStartupDelay=0 关闭偏向锁4秒延迟
        Thread.sleep(4001);
        synchronized (c1) {
            System.out.println("c1第一次加锁后:轻量级锁" + ClassLayout.parseInstance(c1).toPrintable());
        }
        //4秒后的对象，就可以有偏向锁状态，如果没有加锁，
        //则直接是匿名偏向，也就是没有线程竞争锁状态，无线程id信息
        C c = new C();
        System.out.println("VM开启偏向锁后:c是匿名偏向锁" + ClassLayout.parseInstance(c).toPrintable());
        synchronized (c) {
            //对c进行加锁后，出现了线程获取c的Monitor，则会修改为偏向锁
            System.out.println("c第一次加锁后:偏向锁" + ClassLayout.parseInstance(c).toPrintable());
        }
}

打印结果如下：参考下图，判断对象的锁状态
在这里插入图片描述

启动后，c1:无锁com.woniuxy.synchronizedupgrade.C object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           01 00 00 00 (00000`001`锁状态位 00000000 00000000 00000000) (1)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           43 c1 00 f8 (01000011 11000001 00000000 11111000) (-134168253)
     12     4    int C.a                                       0
     16     4    int C.d                                       0
     20     4        (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

c1第一次加锁后:轻量级锁com.woniuxy.synchronizedupgrade.C object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           50 f1 c6 02 (01010000 11110001 11000110 00000010) (46592336)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           43 c1 00 f8 (01000011 11000001 00000000 11111000) (-134168253)
     12     4    int C.a                                       0
     16     4    int C.d                                       0
     20     4        (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

VM开启偏向锁后:c是匿名偏向锁com.woniuxy.synchronizedupgrade.C object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           05 00 00 00 (00000101 00000000 00000000 00000000) (5)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           43 c1 00 f8 (01000011 11000001 00000000 11111000) (-134168253)
     12     4    int C.a                                       0
     16     4    int C.d                                       0
     20     4        (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

c第一次加锁后:偏向锁com.woniuxy.synchronizedupgrade.C object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           05 e8 af 02 (00000101 11101000 10101111 00000010) (45082629)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           43 c1 00 f8 (01000011 11000001 00000000 11111000) (-134168253)
     12     4    int C.a                                       0
     16     4    int C.d                                       0
     20     4        (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

根据第三版《深入理解java虚拟机》第三版13.3.
5偏向锁章节最后几段话，原文如下：

看到这里可能会发现一个问题:
当对象进入偏向状态的时候，Mark Word大部分的空间（23个比特）都用于存储持有锁的线程ID了，这部分空间占用了原有存储对 象哈希码的位置，那原来对象的哈希码怎么办呢?
在Java语言里面一个对象如果计算过哈希码，就应该一直保持该值不变(强烈推荐但不强制，因为用户可以重载hashCode(）方法按自己的意愿返回哈希码)，否则很多依赖对象哈希码的API都可能存在出错风险。而作为绝大多数对象哈希码来源的Object::hashCode(）方法，返回的是对象的一致性哈希码（Identity> Hash> Code)，这个值是能强制保证不变的，它通过在对象头中存储计算结果来保证第一次计算之后，再次调用该方法取到的哈希码值永远不会再发生改变。因此，当一个对象已经计算过一致性哈希码后，它就再也无法进入偏向锁状态了;而当一个对象当前正处于偏向锁状态，又收到需要计算其一致性哈希码请求时，它的偏向状态会被立即撤销，并且锁会膨胀为重量级锁。在重量级锁的实现中，对象头指向了重量级锁的位置，代表重量级锁的ObiectMonitor类里有字段可以记录非加锁状态（标志位为“01”）下的Mark
Word，其中自然可以存储原来的哈希码。
偏向锁可以提高带有同步但无竞争的程序性能，但它同样是一个带有效益权衡（TradeOff）性质的优化，也就是说它并非总是对程序运行有利。如果程序中大多数的锁都总是被多个不同的线程访问，那偏向模式就是多余的。在具体问题具体分析的前提下，有时候使用参数-XX:-UseBiasedLocking来禁止偏向锁优化反而可以提升性能"。

其中，这句话和测试结果有区别：

当一个对象当前正处于偏向锁状态，又收到需要计算其一致性哈希码请求时，它的偏向状态会被立即撤销，并且锁会膨胀为重量级锁。

测试代码如下：

package com.woniuxy.synchronizedupgrade;

import org.openjdk.jol.info.ClassLayout;

class C{
    int a=0;
    int d=0;
    static String b="123";
}
/**
 * Auther: mayuhang  <br/>
 * Date: 2020/7/8:22:21  <br/>
 * Description:
 */
public class  ObjectUpGrade {
    public static void main(String[] args) throws InterruptedException {
        //放在延时前，JVM未开启偏向锁，创建的c1对象，会出现一个问题，它会直接从无锁升级为轻量级锁
        C c1 = new C();
        System.out.println("启动后，c1:无锁" + ClassLayout.parseInstance(c1).toPrintable());
        //预留4s,等待开启偏向锁功能 或者使用命令
        //vm参数： -XX:+UseBiasedLocking开启偏向锁 -XX:BiasedLockingStartupDelay=0 关闭偏向锁4秒延迟
        Thread.sleep(4001);
        synchronized (c1) {
            System.out.println("c1第一次加锁后:轻量级锁" + ClassLayout.parseInstance(c1).toPrintable());
        }
        //4秒后的对象，就可以有偏向锁状态，如果没有加锁，则直接是匿名偏向，也就是没有线程竞争锁状态，无线程id信息
        C c = new C();
        System.out.println("VM开启偏向锁后:c是匿名偏向锁" + ClassLayout.parseInstance(c).toPrintable());
        synchronized (c) {
            //对c进行加锁后，出现了线程获取c的Monitor，则会修改为偏向锁
            System.out.println("c第一次加锁后:偏向锁" + ClassLayout.parseInstance(c).toPrintable());
        }
//      计算HashCode撤销偏向锁
        System.out.println(Integer.toHexString(c.hashCode()));
        System.out.println("计算hash后的状态:c是无锁状态" + ClassLayout.parseInstance(c).toPrintable());
        synchronized (c) {
            System.out.println("第二次加锁后:c直接升级为轻量级锁" + ClassLayout.parseInstance(c).toPrintable());
        }
        new Thread(()->{
            synchronized (c) {
                System.out.println("还未存在线程竞争:c为轻量级锁" + ClassLayout.parseInstance(c).toPrintable());
            }
        }).start();
        new Thread(()->{
            synchronized (c) {
                System.out.println("存在线程竞争:c升级为重量级锁" + ClassLayout.parseInstance(c).toPrintable());
            }
        }).start();
    }
}

结果如下:

启动后，c1:无锁com.woniuxy.synchronizedupgrade.C object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           01 00 00 00 (00000001 00000000 00000000 00000000) (1)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           43 c1 00 f8 (01000011 11000001 00000000 11111000) (-134168253)
     12     4    int C.a                                       0
     16     4    int C.d                                       0
     20     4        (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

c1第一次加锁后:轻量级锁com.woniuxy.synchronizedupgrade.C object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           f8 f7 7f 02 (11111000 11110111 01111111 00000010) (41940984)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           43 c1 00 f8 (01000011 11000001 00000000 11111000) (-134168253)
     12     4    int C.a                                       0
     16     4    int C.d                                       0
     20     4        (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

VM开启偏向锁后:c是匿名偏向锁com.woniuxy.synchronizedupgrade.C object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           05 00 00 00 (00000101 00000000 00000000 00000000) (5)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           43 c1 00 f8 (01000011 11000001 00000000 11111000) (-134168253)
     12     4    int C.a                                       0
     16     4    int C.d                                       0
     20     4        (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

c第一次加锁后:偏向锁com.woniuxy.synchronizedupgrade.C object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           05 e8 68 02 (00000101 11101000 01101000 00000010) (40429573)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           43 c1 00 f8 (01000011 11000001 00000000 11111000) (-134168253)
     12     4    int C.a                                       0
     16     4    int C.d                                       0
     20     4        (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

64a294a6
计算hash后的状态:c是无锁状态com.woniuxy.synchronizedupgrade.C object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           01 a6 94 a2 (00000001 10100110 10010100 10100010) (-1567316479)
      4     4        (object header)                           64 00 00 00 (01100100 00000000 00000000 00000000) (100)
      8     4        (object header)                           43 c1 00 f8 (01000011 11000001 00000000 11111000) (-134168253)
     12     4    int C.a                                       0
     16     4    int C.d                                       0
     20     4        (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

第二次加锁后:c直接升级为轻量级锁com.woniuxy.synchronizedupgrade.C object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           f8 f7 7f 02 (11111000 11110111 01111111 00000010) (41940984)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           43 c1 00 f8 (01000011 11000001 00000000 11111000) (-134168253)
     12     4    int C.a                                       0
     16     4    int C.d                                       0
     20     4        (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

还未存在线程竞争:c为轻量级锁com.woniuxy.synchronizedupgrade.C object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           20 f5 ae 21 (00100000 11110101 10101110 00100001) (565114144)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           43 c1 00 f8 (01000011 11000001 00000000 11111000) (-134168253)
     12     4    int C.a                                       0
     16     4    int C.d                                       0
     20     4        (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

存在线程竞争:c升级为重量级锁com.woniuxy.synchronizedupgrade.C object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           5a 2d b8 1c (01011010 00101101 10111000 00011100) (481832282)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           43 c1 00 f8 (01000011 11000001 00000000 11111000) (-134168253)
     12     4    int C.a                                       0
     16     4    int C.d                                       0
     20     4        (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

总结

升级状态，全部都实现了一遍。
从无锁，到匿名偏向锁，到偏向锁，到轻量级锁，到重量级锁。
如果需要根据引用的文章，测试偏向锁计算HashCode后直接升级为重量级锁，代码如下：

package com.woniuxy.synchronizedupgrade;

import org.openjdk.jol.info.ClassLayout;

class C{
    int a=0;
    int d=0;
    static String b="123";
}
/**
 * Auther: mayuhang  <br/>
 * Date: 2020/7/8:22:21  <br/>
 * Description:
 */
public class  ObjectUpGrade {
    public static void main(String[] args) throws InterruptedException {
        //放在延时前，JVM未开启偏向锁，创建的c1对象，会出现一个问题，它会直接从无锁升级为轻量级锁
        C c1 = new C();
        System.out.println("启动后，c1:无锁" + ClassLayout.parseInstance(c1).toPrintable());
        //预留4s,等待开启偏向锁功能 或者使用命令
        //vm参数： -XX:+UseBiasedLocking开启偏向锁 -XX:BiasedLockingStartupDelay=0 关闭偏向锁4秒延迟
        Thread.sleep(4001);
        synchronized (c1) {
            System.out.println("c1第一次加锁后:轻量级锁" + ClassLayout.parseInstance(c1).toPrintable());
        }
        //4秒后的对象，就可以有偏向锁状态，如果没有加锁，则直接是匿名偏向，也就是没有线程竞争锁状态，无线程id信息
        C c = new C();
        System.out.println("VM开启偏向锁后:c是匿名偏向锁" + ClassLayout.parseInstance(c).toPrintable());
        synchronized (c) {
            //对c进行加锁后，出现了线程获取c的Monitor，则会修改为偏向锁
            System.out.println("c第一次加锁后:偏向锁" + ClassLayout.parseInstance(c).toPrintable());
        }
        synchronized (c) {
            c.hashCode();
            System.out.println("第二次加锁后:计算HashCode后偏向直升重量级锁：" + ClassLayout.parseInstance(c).toPrintable());
        }
    }
}


启动后，c1:无锁com.woniuxy.synchronizedupgrade.C object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           01 00 00 00 (00000001 00000000 00000000 00000000) (1)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           43 c1 00 f8 (01000011 11000001 00000000 11111000) (-134168253)
     12     4    int C.a                                       0
     16     4    int C.d                                       0
     20     4        (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

c1第一次加锁后:轻量级锁com.woniuxy.synchronizedupgrade.C object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           98 f3 bf 02 (10011000 11110011 10111111 00000010) (46134168)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           43 c1 00 f8 (01000011 11000001 00000000 11111000) (-134168253)
     12     4    int C.a                                       0
     16     4    int C.d                                       0
     20     4        (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

VM开启偏向锁后:c是匿名偏向锁com.woniuxy.synchronizedupgrade.C object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           05 00 00 00 (00000101 00000000 00000000 00000000) (5)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           43 c1 00 f8 (01000011 11000001 00000000 11111000) (-134168253)
     12     4    int C.a                                       0
     16     4    int C.d                                       0
     20     4        (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

c第一次加锁后:偏向锁com.woniuxy.synchronizedupgrade.C object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           05 e8 6b 02 (00000101 11101000 01101011 00000010) (40626181)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           43 c1 00 f8 (01000011 11000001 00000000 11111000) (-134168253)
     12     4    int C.a                                       0
     16     4    int C.d                                       0
     20     4        (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

第二次加锁后:计算HashCode后偏向直升重量级锁：com.woniuxy.synchronizedupgrade.C object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           9a 45 ba 1c (10011010 01000101 10111010 00011100) (481969562)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           43 c1 00 f8 (01000011 11000001 00000000 11111000) (-134168253)
     12     4    int C.a                                       0
     16     4    int C.d                                       0
     20     4        (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
SIDOS007
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
关于Java中HashCode方法的深入理解
08-25
主要给大家介绍了关于Java中HashCode方法的相关资料，文中通过示例代码介绍的非常详细，对大家学习或者使用Java具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
关于Object中equals方法和hashCode方法判断的分析
08-26
今天小编就为大家分享一篇关于关于Object中equals方法和hashCode方法判断的分析，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
synchronized关键字(锁升级案例)
qq_36098514的博客
02-22 231
synchronized关键字
(SUB)对象头及sync锁升级详解
jay的博客
09-08 1011
MarkWord biased_lock：对象是否启用偏向锁标记，只占1个二进制位。为1时表示对象启用偏向锁，为0时表示对象没有偏向锁。lock和biased_lock共同表示对象处于什么锁状态。 lock:2位的锁状态标记位，由于希望用尽可能少的二进制位表示尽可能多的信息，所以设置了lock标记。该标记的值不同，整个Mark Word表示的含义不同。biased_lock和lock一起，表达锁状态 age：4位的Java对象年龄。在GC中，如果对象在Survivor区复制一次，年龄增...
Java锁升级过程
summer_fish的专栏
09-11 659
Java锁升级过程Java对象头二、锁种类三、具体过程 Java对象头 synchronized用的锁存在Java对象头里，Java对象头里的Mark Word默认存储对象的HashCode、分代年龄和锁标记位。在运行期间，Mark Word里存储的数据会随着锁标志位的变化而变化。32位JVM的Mark Word可能变化存储为以下5种数据： 锁一共有四种状态，级别从低到高依次是：无锁状态、偏向锁状态、轻量级锁状态和重量级锁状态，这几个状态随着竞争情况逐渐升级。为了提高获得锁和释放锁的效率，锁可以升级但不能
Java 对象头：理解锁升级
ChineseSoftware的博客
01-12 830
一、简述 在 JVM 中，对象在堆内存中的布局分为三块区域：对象头、实例变量和填充数据。 1️⃣【对象头区域】Java对象的对象头由 mark word 和 class pointer 两部分组成。 对象自身的运行时数据(MarkWord)。 存储 hashcode、GC 分代年龄、锁类型标记、偏向锁线程 ID、CAS 锁指向线程 LockRecord 的指针等，synchronized 锁的机制与这个部分(markwork)密切相关，用 markword 中最低的三位代表锁的状态，其中一位是偏向锁位
锁的四种状态与锁升级过程 图文详解
最新发布
m0_66328098的博客
07-20 3210
无锁、偏向锁、轻量级锁、重量级锁，这四种锁状态分别代表什么，为什么会有锁升级？其实在 JDK 1.6之前，synchronized 还是一个重量级锁，是一个效率比较低下的锁，但是在JDK 1.6后，Jvm为了提高锁的获取与释放效率对（）进行了优化，引入了偏向锁 和 轻量级锁，从此以后锁的状态就有了四种（无锁、偏向锁、轻量级锁、重量级锁），并且四种状态会随着竞争的情况逐渐升级，而且是不可逆的过程，即不可降级，也就是说只能进行锁升级（从低级别到高级别），不能锁降级（高级别到低级别）
深入了解JVM锁升级过程
阳谋大师的博客
04-10 344
本篇文章是在一位大佬的文章基础上进行微调后的，大佬文章连接对于java锁升级，很多人都停留在比较浅层的表面理解，一定程度下也许够用，但如果学习其中的细节，因此我将锁升级过程中可能涉及的大部分细节或者疑问都整合成了一篇文章，希望你能直接在这篇文章中，搞懂你当年学习这块时遗留的所有疑问。
Java synchronized偏向锁后hashcode存在哪里？
weixin_40980639的博客
07-22 836
XX关闭延时。hashcode是懒加载，在调用hashCode方法后才会保存在对象头中。当对象头中没有hashcode时，对象头锁的状态是可偏向（biasable，101，且无线程id）。如果在同步代码块之前调用hashCode方法，则对象头中会有hashcode，且锁状态是不可偏向（001），这时候再执行同步代码块，锁直接是轻量级锁（thinlock，00）。如果是在同步代码块中执行hashcode，则锁是从偏向锁直接膨胀为重量级锁。Java技能树集合41328。...
Synchronized锁升级原理与过程深入剖析
m0_71777195的博客
08-16 578
在本篇文章当中我们主要介绍了synchronized内部锁升级的原理，具体的锁升级的过程是：无🔒->偏向🔒->轻量级🔒->重量级🔒。无锁：这是没有开启偏向锁的时候的状态，在JDK1.6之后偏向锁的默认开启的，但是有一个偏向延迟，需要在JVM启动之后的多少秒之后才能开启，这个可以通过JVM参数进行设置，同时是否开启偏向锁也可以通过JVM参数设置。......
通过Lombok学习如何写好hashCode和equals方法
sunct的博客
03-22 6730
平时开发过程中，有时需要重写javaBean的hashCode和equals方法，但是一时间却不知道如何编写，百度上一搜索各种写法，总感觉没一个是标准写法。还好，Lombok的@Data会自动给JavaBean填充hashCode和equals方法，可以通过反编译出来，学习下Lombok如何重写hashCode和equals方法的。 import lombok.Data; import java...
java学习第43天，重写hashcode
Sukla的博客
11-02 196
1，hashCode 返回的整数相同的时候 要求 key 做 equals 比较必须返回 true 2，hashCode 多次接受同一个参数 计算之后返回的整数不能有变化 要保持稳定性
Java中hashCode的作用
12-22
以下是关于HashCode的官方文档定义： 　hashcode方法返回该对象的哈希码值。支持该方法是为哈希表提供一些优点，例如，java.util.Hashtable 提供的哈希表。 　hashCode 的常规协定是： 　在Java应用程序执行期间...
java 中HashCode重复的可能性
08-29
主要介绍了java 中HashCode重复的可能性的相关资料,这里提供实例及测试代码，需要的朋友可以参考下
Java提高篇之hashCode
12-22
在前面三篇博文中LZ讲解了（HashMap、HashSet、HashTable），在其中LZ不断地讲解他们的put和get方法，在这两个方法中计算key的hashCode应该是重要也是精华的部分，所以下面LZ揭开hashCode的“神秘”面纱。...
PPT浅析hashcode
12-28
PPT浅析hashcode定义和作用；和简单的代码演示PPT.很简单的
浅谈Java中的hashcode方法
01-20
　public native int hashCode(); 　根据这个方法的声明可知，该方法返回一个int类型的数值，并且是本地方法，因此在Object类中并没有给出具体的实现。 　为何Object类需要这样一个方法？它有什么作用呢？我们来...
hashCode方法的使用讲解
09-05
有许多人学了很长时间的Java，但一直不明白hashCode方法的作用，我来解释一下吧。
hashcode2018:提交Hashcode 2018
05-17
hashcode2018 我们为Hashcode 2018提交的内容。 我们共获得35 850 929分，全球排名1570/4856，法国排名208/628。 真是美好的时光。
为什么重写equals方法后还要重写hashcode
05-17
在Java中，`equals()`方法和`hashCode()`方法是密切相关的。当我们对一个对象重写了`equals()`方法时，我们通常还需要重写`hashCode()`方法。 `hashCode()`方法返回一个`int`类型的哈希码值，用于快速查找对象。如果两个对象通过`equals()`方法比较相等，则它们的哈希码值必须相等。因此，如果你重写了`equals()`方法而没有重写`hashCode()`方法，那么可能会导致哈希表中存储的对象无法正确地查询、删除或更新。 所以，为了保证哈希表的正确性，我们必须重写`hashCode()`方法，使得它与`equals()`方法保持一致。具体来说，如果两个对象通过`equals()`方法比较相等，那么它们的哈希码值必须相等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值