精华内容
下载资源
问答
  • java对象数组 创建对象数组,初始化对象数组

    万次阅读 多人点赞 2019-07-30 16:34:15
    对象数组的概念: 如果一个数组中的元素是对象类型,则称该数组为对象数组。 当需要一个类的多个对象时,应该用该类的对象数组来表示,通过改变下标值就可以访问到不同的对象对象数组的定义和使用: 对象数组的...

    对象数组的概念:
    如果一个数组中的元素是对象类型,则称该数组为对象数组。
    当需要一个类的多个对象时,应该用该类的对象数组来表示,通过改变下标值就可以访问到不同的对象。
    对象数组的定义和使用:
    对象数组的定义与一般数组的定义类似,但是需要为每一个元素实例化。
    对象数组的声明形式是:
    类名 对象数组名 [ ];
    为对象数组分配内存空间:
    对象数组名=new 类名[数组长度];//注意 :此处不是构造方法了
    可以将对象数组的声明和创建用一条语句来完成。例如:定义一个学生类对象数组,可以用下面的语句定义:Student stu[ ]=new Student[30]; stu [ ]是对象数组名,它所表示的数组一共有30个元素,每一个元素都是Student类的对象名,还没有实例化,所以还必须为每一个元素实例化。比如如下的过程:
    for(int i=0;i<stu.length;i++)
    stu[i]=new Student();
    实例化以后就可以使用每一个元素对象。
    设计一个雇员类,并创建雇员类的对象数组,输出每个雇员的信息

    //设计一个雇员类,并创建雇员类的对象数组,输出每个雇员的信息
    class Employee {   //雇员类
     private String id;  //编号
     private String name; //姓名
     private int age;     //年龄
     private String vocation; //职务
     public Employee(){} //构造方法一
     public Employee(String id,String name,int age,String vocation){
      set(id,name,age,vocation);
     }
     //设置属性的方法
     public void set(String id,String name,int age,String vocation){
      this.id=id;
      this.name=name;
      this.age=age;
      this.vocation=vocation;
     }
     public String toString() {
      String mess=id+","+name+","+age+","+vocation;
      return mess;
     }
    }
    public class Example4  {
     public static void main(String[] args) {
      Employee 雇员[]=new Employee[3];
      int i;
      for(i=0;i<雇员.length;i++)//为对象数组中每一个元素实例化
      雇员[i]=new Employee();//如果没有写构造方法一,而这样写,会出错
      //因为类中有有参的构造方法,系统就不会在默认给无参的构造方法了,
      //所以当类中写了有参的构造方法后,要用无参的构造方法时必须写出来
      
      //每一个对象元素分别初始化
      雇员[0].set("0001","张文军",50,"总经理");
      雇员[1].set("0002","李琦",45,"副经理");
      雇员[2].set("1016","张丽",28,"秘书");
      for (Employee employee:雇员)
       System.out.println(employee.toString());
     }
    }
    

    在这里插入图片描述
    普通型for循环和增强型for循环
    普通型

    a={1,2,3,4,5};
    for(int i=0;i<a.length;i++) {
     System.out.println9(a[1]);
    }
    

    增强型

    for(int element:a) {
    System.out.println(element);
    }
    

    两者结果相同,但是增强型更为简洁

    对象数组还可以采用初始化的方法创建。创建形式是:
    类名 对象数组名[ ]={对象列表};

    设计一个雇员类,创建雇员类的对象数组并初始化,输出每个雇员的信息,仍然沿用上面的Employee类,程序如下

    class Employee {   //雇员类
     private String id;  //编号
     private String name; //姓名
     private int age;     //年龄
     private String vocation; //职务
     public Employee(){} //构造方法一
     public Employee(String id,String name,int age,String vocation){
      set(id,name,age,vocation);
     }
     //设置属性的方法
     public void set(String id,String name,int age,String vocation){
      this.id=id;
      this.name=name;
      this.age=age;
      this.vocation=vocation;
     }
     public String toString() {
      String mess=id+","+name+","+age+","+vocation;
      return mess;
     }
    }
    public class Example11 {
     public static void main(String[] args) {
      //先创建3个雇员对象
      Employee employee1=new Employee("0001","张文军",50,"总经理");
      Employee employee2=new Employee("0005","李琦",45,"副经理");
      Employee employee3=new Employee("1016","张丽",28,"秘书");
      //声明对象数组并直接初始化
      Employee 雇员1[]={employee1,employee2,employee3};
      output(雇员1);//输出雇员信息
      System.out.println("------------------");//分割线
      //声明对象数组并直接初始化,初始化元素直接调用
      //构造方法创建对象
      Employee 雇员2[]={new Employee("0001","张文军",50,"总经理"),
      new Employee("0005","李琦",45,"副经理"),
      new Employee("1016","张丽",28,"秘书")};
      output(雇员2);
     }
     //定义方法用于输出雇员信息,注意方法是private,static
     private static void output(Employee 雇员[]){
      for(Employee employee:雇员)
       System.out.println(employee.toString());
     }
    }
    

    在这里插入图片描述

    展开全文
  • 什么是Java的对象引用? Java中都有哪些类型的对象引用? Java中提供的Java对象引用主要有什么目的? 通过本文,你就能很清楚得了解Java的对象引用

    Java对象的引用

    一、概念,什么是Java对象的引用?
      每种编程语言都有自己的数据处理方式。有些时候,程序员必须注意将要处理的数据是什么类型。你是直接操纵元素,还是用某种基于特殊语法的间接表示(例如C/C++里的指针)来操作对象。所有这些在 Java 里都得到了简化,一切都被视为对象。因此,我们可采用一种统一的语法。尽管将一切都“看作”对象,但操纵的标识符实际是指向一个对象的“引用”(reference)。 对Java对象的引用,是描述的定义。 
      
    二、Java对象引用的目的
    Java中提供这四种引用类型主要有两个目的:
    第一是 可以让程序员通过代码的方式决定某些对象的生命周期
    第二是 有利于JVM进行垃圾回收

    三、四中Java对象的引用
    Java对象的引用包括:强引用,软引用,弱引用,虚引用
    强引用:是指创建一个对象并把这个对象赋给一个引用变量。
    软引用:如果一个对象具有软引用,内存空间足够,垃圾回收器就不会回收它;
    如果内存空间不足了,就会回收这些对象的内存。只要垃圾回收器没有回收它,该对象就可以被 程序使用。软引用可用来实现内存敏感的高速缓存,比如网页缓存、图片缓存等。使用软引用能防止内存泄露,增强程序的健壮性。
    SoftReference的特点是它的一个实例保存对一个Java对象的软引用, 该软引用的存在不妨碍垃圾收集线程对该Java对象的回收。
    弱引用:WeakReference弱引用也是用来描述非必需对象的,当JVM进行垃圾回收时,无论内存是否充足,都会回收被弱引用关联的对象。在java中,用java.lang.ref.WeakReference类来表示。
    虚引用:虚引用(PhantomReference) 虚引用和前面的软引用、弱引用不同,它并不影响对象的生命周期。在java中用java.lang.ref.PhantomReference类表示。如果一个对象与虚引用关联,则跟没有引用与之关联一样,在任何时候都可能被垃圾回收器回收 。

    要注意的是,虚引用必须和引用队列关联使用,当垃圾回收器准备回收一个对象时,如果发现它还有虚引用,就会把这个虚引用加入到与之 关联的引用队列中。程序可以通过判断引用队列中是否已经加入了虚引用,来了解被引用的对象是否将要被垃圾回收。如果程序发现某个虚引用已经被加入到引用队列,那么就可以在所引用的对象的内存被回收之前采取必要的行动。

    展开全文
  • java对象头信息

    千次阅读 多人点赞 2019-09-02 14:27:14
    1. 一个java对象到底占用了多少内存空间,应该如何计算? 2. 为什么在jdk1.6后,synchronized关键字性能有所提高,为什么会提高?并且很多文章中都说synchronized锁有偏向锁、轻量锁、重量锁等状态? 3. java对象...

    做java开发几年了,但一直不知道如下问题:

    1. 一个java对象到底占用了多少内存空间,应该如何计算?

    2. 为什么在jdk1.6后,synchronized关键字性能有所提高,为什么会提高?并且很多文章中都说synchronized锁有偏向锁、轻量锁、重量锁等状态?

    3. java对象是在那里设置了指针指向对应的方法区中的元数据的?

    4. 在jvm垃圾回收时被标记为可回收但还未执行回收时,java对象是什么状态?

    5. jvm怎么确定 一个java对象的GC年龄?

    6. 为什么对象在经历过最多15次GC后,就会被移动到老年代中?

    带着上述问题,最近终于找到了答案,于是记录了下来。

    在java中,一个对象是具有相关的状态的,这状态都是保存在java对象的对象头中的。本文以64位进行说明。

    1. 概述

    java对象由如下几部分组成:

    1. 对象头:Mark word和klasspointer两部分组成,如果是数组,还包括数组长度

    2. 实例属性

    3. 对齐填充

    如何能看到上图结构?

    注意:要打印上述内存结构图,需要引入如下依赖:

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

    2. 对象头

    64位对象头由Mark Word、klass pointer两部分组成,如果对象是数组,则还要加上数组长度,即三部分组成。

    Mark Word由64位8个字节组成。

    klass pointer由64位8个字节组成,但我们使用的64位 JVM会默认使用选项 +UseCompressedOops 开启指针压缩,将指针压缩至32位。即上面截图中的klass pointer为4个字节32位。

    类指针klass pointer和数组长度,很简单这里不在描述,重点描述下Mark Word部分。

    Mark Word的64位,不同的位表示的意思不一样,具体如下所示:

    |--------------------------------------------------------------------------------------------------------------|
    |                                              Object Header (128 bits)                                        |
    |--------------------------------------------------------------------------------------------------------------|
    |                        Mark Word (64 bits)                                    |      Klass Word (64 bits)    |       
    |--------------------------------------------------------------------------------------------------------------|
    |  unused:25 | identity_hashcode:31 | unused:1 | age:4 | biased_lock:1 | lock:2 |     OOP to metadata object   |  无锁
    |----------------------------------------------------------------------|--------|------------------------------|
    |  thread:54 |         epoch:2      | unused:1 | age:4 | biased_lock:1 | lock:2 |     OOP to metadata object   |  偏向锁
    |----------------------------------------------------------------------|--------|------------------------------|
    |                     ptr_to_lock_record:62                            | lock:2 |     OOP to metadata object   |  轻量锁
    |----------------------------------------------------------------------|--------|------------------------------|
    |                     ptr_to_heavyweight_monitor:62                    | lock:2 |     OOP to metadata object   |  重量锁
    |----------------------------------------------------------------------|--------|------------------------------|
    |                                                                      | lock:2 |     OOP to metadata object   |    GC
    |--------------------------------------------------------------------------------------------------------------|

    lock:  锁状态标记位,该标记的值不同,整个mark word表示的含义不同。

    biased_lock:偏向锁标记,为1时表示对象启用偏向锁,为0时表示对象没有偏向锁。

    age:Java GC标记位对象年龄,4位的表示范围为0-15,因此对象经过了15次垃圾回收后如果还存在,则肯定会移动到老年代中。

    identity_hashcode:对象标识Hash码,采用延迟加载技术。当对象使用HashCode()计算后,并会将结果写到该对象头中。当对象被锁定时,该值会移动到线程Monitor中。

    thread:持有偏向锁的线程ID和其他信息。这个线程ID并不是JVM分配的线程ID号,和Java Thread中的ID是两个概念。

    epoch:偏向时间戳。

    ptr_to_lock_record:指向栈中锁记录的指针。

    ptr_to_heavyweight_monitor:指向线程Monitor的指针。

    2.1 无锁状态时Mark Word-001

    当一个对象才new且调用了hashcode方法后(如果不调用hashcode方法,那么存放hashcode的31位全部为0),正常情况下处于无锁状态,无锁状态时,Mark Word的64位分别为:前25位未使用,接下来的31位为对象的hashcode,接下来的1位未使用,接下来的4位表示对象的GC年龄,接下来的一位为偏向锁状态,最后2位表示锁状态。如下图所示:

    2.2 偏向锁状态时的Mark Word-101

    理论上而言,u对象应该是无锁状态啊,变成为偏向锁了呢?如果把sleep注释掉真的就是无锁状态。

    JVM启动时会进行一系列的复杂活动,比如装载配置,系统类初始化等等。在这个过程中会使用大量synchronized关键字对对象加锁,且这些锁大多数都不是偏向锁。为了减少初始化时间,JVM默认延时加载偏向锁。这个延时的时间大概为4左右,具体时间因机器而异。当然我们也可以设置JVM参数 -XX:BiasedLockingStartupDelay=0 来取消延时加载偏向锁。

    此时占用 thread 和 epoch 的 位置的均为0,说明当前偏向锁并没有偏向任何线程。此时这个偏向锁正处于可偏向状态,准备好进行偏向了!你也可以理解为此时的偏向锁是一个特殊状态的无锁

    2.3 轻量级锁状态时的Mark Word-000

    所谓轻量级锁是指虽然代码中有synchronized关键字加锁,但jvm在执行时,不存在并发问题,这时jvm会优化成轻量级锁,如下代码所示:

    public class SyncTest {
    
        public static void main(String[] args) throws Exception {
            final User a = new User();
    
            Thread thread1 = new Thread(){
                @Override
                public void run() {
                    synchronized (a){
                        System.out.println("thread1 locking");
                        System.out.println(ClassLayout.parseInstance(a).toPrintable());
                    }
                    try {
                        //thread1退出同步代码块,且没有死亡
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            };
    
            Thread thread2 = new Thread(){
                @Override
                public void run() {
                    synchronized (a){
                        System.out.println("thread2 locking");
                        System.out.println(ClassLayout.parseInstance(a).toPrintable());
                    }
                }
            };
            thread1.start();
    
            //让thread1执行完同步代码块中方法。
            Thread.sleep(3000);
            thread2.start();
        }
    }

    2.4 重量级锁状态时的Mark Word-010

    即在执行代码时真的会存在锁争抢的情况,如下代码所示:

    public class SyncTest {
    
        public static void main(String[] args) throws Exception {
            final User a = new User();
    
            Thread thread1 = new Thread(){
                @Override
                public void run() {
                    synchronized (a){
                        System.out.println("thread1 locking");
                        System.out.println(ClassLayout.parseInstance(a).toPrintable());
                    }
                    try {
                        //thread1退出同步代码块,且没有死亡
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            };
    
            Thread thread2 = new Thread(){
                @Override
                public void run() {
                    synchronized (a){
                        System.out.println("thread2 locking");
                        System.out.println(ClassLayout.parseInstance(a).toPrintable());
                        try {
                            //thread1退出同步代码块,且没有死亡
                            Thread.sleep(3000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            };
            thread1.start();
            thread2.start();
        }
    }

    3.对象属性数据区

    int---4个字节

    long--8个字节

    double--8个字节

    float--4个字节

    short--2个字节

    char--2个字节(为什么是2个字节,不应该是一个字节么?难道跟编码有关?)

    Boolean--1个字节

    byte--1个字节

    java对象--4个字节

    4. 对齐填充区

    Java对象占用空间是8字节对齐的,即所有Java对象占用字节数必须是8的倍数。如下图所示:

    这个对象一个占用了24个字节,其中MarkWord+klasspointer+short+char+boolean+byte+对齐填充=18+对齐填充,而比18大且是8的整数倍的最小值为24,因此这个对象的对齐填充为6,整个对象大小为24字节。

    对此,本章节前的几个问题就都有了答案,get get get!!!

     

    展开全文
  • JVM成神之路-Java对象模型

    千次阅读 2018-07-23 15:01:17
    一个Java对象可以分为三部分存储在内存中,分别是:对象头(Header)、实例数据(Instance Data)和对齐填充(Padding)。 对象头(包含锁状态标志,线程持有的锁等标志) 实例数据 对齐填充 oop-klass model(...

    首先我们要知道:

    在jvm的内存结构中,对象保存在堆中,而我们在对对象进行操作时,其实操作的是对象的引用。

    Java对象包含三个部分

    一个Java对象可以分为三部分存储在内存中,分别是:对象头(Header)、实例数据(Instance Data)和对齐填充(Padding)。

    1. 对象头(包含锁状态标志,线程持有的锁等标志)
    2. 实例数据
    3. 对齐填充

    oop-klass model(hotspot jvm中的对象模型)

    Java虚拟机的底层是使用c++实现,而jvm并没有根据一个Java的实例对象去创建对应的c++对象,而是设计了一个oop-klass model ;

    1. OOP(Ordinary Object Pointer):普通对象指针; 表示一个实例信息
    2. Klass:描述对象实例的具体类型, 含了元数据和方法信息
    3. 创建目的:不想让每个对象中都含有一个vtable(虚函数表)

    类就是一类事物的抽象概括。

    OOP体系:

    1. OOPs模块中包含了多个子模块,每个子模块对应一个类型,每一个类型的OOP都代表一个在JVM内部使用的特定对象的类型。
    2. 在Java程序运行过程中,每创建一个新的对象,在JVM内部就会相应的创建一个对应类型的OOP对象。

    代码:

    1. typedef class oopDesc* oop;

    // 定义了oop共同的基类,其他的类型都是它的子类

    1. typedef class instanceOopDesc* instanceOop;

    /* 表示一个Java类型实例,每当我们new一个对象时,

    JVM都会创建一个instanceOopDesc */

    1. typedef class methodOopDesc* methodOop;

    // 表示一个Java方法

    1. typedef class constMethodOopDesc* constMethodOop;

    // 表示一个Java方法中的不变信息

    1. typedef class MethodDataOopDesc* methodDataOop;

    // 记录性能信息的数据结构

    1. typedef class arrayOopDesc* arrayOop;

    /* 定义了数组oops的抽象基类,下面两个类相当于此类的子类,

    new一个数组时会建立此对象*/

    1. typedef class objArrayOopDesc* objArrayOop;

    // 表示持有一个oops数组,对应存储对象的数组

    1. typedef class typeArrayOopDesc* typeArrayOop;

    // 表示容纳基本类型的数组,对应存储基本类型的数组

    1. typedef class constantPoolOopDesc* constantPoolOop;

    // 表示在class文件中描述的常量池

    1. typedef class constantPoolCacheOopDesc* constantPoolCacheOop;

    // 常量池缓存

    1. typedef class klassOopDesc* klassOop;

    // 描述一个与Java类对等的C++类

    1. typedef class markOopDesc* markOop;

    // 表示对象头

    OopDesc结构:

    class oopDesc {

     friend class VMStructs;

            private:

    /*

    * 实际上也是代表了instanceOopDesc、arrayOopDesc和OopDesc

    * 包含了markOop _mark和union_matadata两部分

    */

    volatile markOop _mark; // 保存锁标记、gc分代等信息

    union _metadata { wideKlassOop _klass; // 普通指针,

    // 压缩类指针,和普通指针都指向instanceKlass 对象

    narrowOop _compressed_klass; } _metadata;

    private:

     // 实例数据保存的位置

    void* field_base(int offset) const;

    jbyte* byte_field_addr(int offset) const;

    jchar* char_field_addr(int offset) const;

    jboolean* bool_field_addr(int offset) const;

    jint* int_field_addr(int offset) const;

    jshort* short_field_addr(int offset) const;

    jlong* long_field_addr(int offset) const;

    jfloat* float_field_addr(int offset) const;

    jdouble* double_field_addr(int offset) const;

    address* address_field_addr(int offset) const; }

    /* instanceOopDesc和arrayOopDesc都直接继承了oopDesc,

    都没有增加其他的数据结构 */

    class instanceOopDesc : public oopDesc {

    }

    class arrayOopDesc : public oopDesc { }

    1. 职能:表示对象的实例数据,不含任何虚函数
    2. 对象在内存中的基本形式就是oop
    3. 对象所属的类也是一种oop,即klassOop,对应的klass是klassKlass

    Klass体系:

    结构:

    • class Klass;

    // klassOop的一部分,用来描述语言层的类型,其他所有类的父类

    • class instanceKlass;

    // 在虚拟机层面描述一个Java类,每一个已加载的Java类都会创建一个此对象,

    // 在JVM层表示Java类

    • class instanceMirrorKlass;

    // 专有instantKlass,表示java.lang.Class的Klass

    • class instanceRefKlass;

    // 专有instantKlass,表示java.lang.ref.Reference的子类的Klass

    • class methodKlass; // 表示methodOop的Klass
    • class constMethodKlass; // 表示constMethodOop的Klass
    • class methodDataKlass; // 表示methodDataOop的Klass
    • class klassKlass; // 最为klass链的端点,klassKlass的Klass就是它自身
    • class instanceKlassKlass; // 表示instanceKlass的Klass
    • class arrayKlassKlass;

    // 表示arrayKlass的Klass

    • class objArrayKlassKlass; // 表示objArrayKlass的Klass
    • class typeArrayKlassKlass; // 表示typeArrayKlass的Klass
    • class arrayKlass; // 表示array类型的抽象基类
    • class objArrayKlass; // 表示objArrayOop的Klass
    • class typeArrayKlass; // 表示typeArrayOop的Klass
    • class constantPoolKlass; // 表示constantPoolOop的Klass
    • class constantPoolCacheKlass;

    // 表示constantPoolCacheOop的Klass

    功能:

        • 实现语言层面的Java类(在Klass基类中已经实现)
        • 实现Java对象的分发功能(由Klass子类提供虚函数实现)

    目的:为了实现虚函数多态,提供了虚函数表。

    • instanceKlass的内部结构:
    • objArrayOop _methods;

    // 类拥有的方法

    • typeArrayOop _method_ordering;

    //描述方法顺序

    • objArrayOop _local_interfaces;

    //实现的接口

    • objArrayOop _transitive_interfaces;

    //继承的接口

    • typeArrayOop _fields;

    //域

    • constantPoolOop _constants;

    //常量

    • oop _class_loader;

    //类加载器

    • oop _protection_domain;

    //protected域

    ....

    HotSpotJVM的设计这把对象一拆为二,分为Klass和oop,其中oop的只能主要在于表示对象的实例数据,所以其中不含有任何虚函数,而klass为了实现虚函数多态,所以提供了虚函数表。所以,关于java的多态,其实也有虚函数的影子在。

    instanceKlass

    JVM在运行时,需要一种用来标识Java内部类型的机制。在HotSpot中的解决方案是:为每一个已加载的Java类创建一个instanceKlass对象,用来在JVM层表示Java类。

    结构:

    //类拥有的方法列表

      objArrayOop     _methods;

      //描述方法顺序

      typeArrayOop    _method_ordering;

      //实现的接口

      objArrayOop     _local_interfaces;

      //继承的接口

      objArrayOop     _transitive_interfaces;

      //域

      typeArrayOop    _fields;

      //常量

      constantPoolOop _constants;

      //类加载器

      oop             _class_loader;

      //protected域

      oop             _protection_domain;

          ....

    在JVM中,对象在内存中的基本存在形式就是oop。那么,对象所属的类,在JVM中也是一种对象,因此它们实际上也会被组织成一种oop,即klassOop。同样的,对于klassOop,也有对应的一个klass来描述,它就是klassKlass,也是klass的一个子类。

    klassKlass作为oop的klass链的端点。关于对象和数组的klass链大致如下图:

    oop-klass-klassKlass关系图:

    符号引用

    符号引用就是用一组符号来描述所引用的目标,我们都知道在Java中,通常情况下我们写的一个Java类被编译以后都是一个class文件,在编译的时候,Java类并不知道所引用的类的实际地址,因此只能使用符号引用来代替。

    一般一个对象的创建就是从new开始的,而操作这些创建指令的就是jvm了,首先当你开始new的时候,jvm会先去查找一个符号引用,如果找不到这个符号引用就说明这个类还没有被加载,因此jvm就会进行类加载,然后符号引用被解析完成,紧接着jvm会为对象在堆内存中分配内存,也就是说我们这个user对象就在堆内存中有一块内存空间了。

    HotSpot虚拟机实现的Java对象包括三个部分:对象头,实例字段和对齐填充

    为对象分配完堆内存之后,jvm会将该内存进行零值初始化。

    内存存储:

    关于一个Java对象,他的存储是怎样的,一般很多人会回答:对象存储在堆上。稍微好一点的人会回答:对象存储在堆上,对象的引用存储在栈上。今天,再给你一个更加显得牛逼的回答:

    对象的实例(instantOopDesc)保存在堆上,对象的元数据(instantKlass)保存在方法区,对象的引用保存在栈上。

    其实如果细追究的话,上面这句话有点故意卖弄的意思。因为我们都知道。方法区用于存储虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。 所谓加载的类信息,其实不就是给每一个被加载的类都创建了一个 instantKlass对象么。

    示例

    class Model{
    public static int a = 1;
    private final int NUMBER = 2;
    public int b;
    public int c = 3;
    
    public Model(int b){
    this.b = b;
    }
    
    public static void main(String[] args){
    int d = 10;
    Model modelA = new Model(2);
    Model modelB = new Model(3);
    }
    }
    

    存储结构:

    总结:

    在Java中,JVM中的对象模型包含两部分:Oop和Klass,在类被加载的时候,JVM会给类创建一个instanceKlass,其中包含了类信息、常量、静态变量、即时编译器编译后的代码等,存储在方法区,用来在JVM层表示该Java类。而使用new一个对象后,JVM就会创建一个instanceOopDesc对象,该对象包含对象头和实例数据,对象头中保存的是锁的状态标志等信息,元数据则实际上是一个指针,指向instanceKlass

    Java对象模型---对象头(Mark Word)

    对象自身的运行时数据

    这部分存储包括哈希码(HashCode)、GC分代年龄、锁状态标志、线程持有的锁、偏向线程ID、偏向时间戳等。这部分数据被官方称为Mark Word,在32位和64位的虚拟机中的大小分别为32bit和64bit。

    由于对象头信息是与对象自身定义的数据无关的额外存储成本,考虑到虚拟机的空间效率,Mark Word被设计成一个非固定的数据结构以提高存储空间的利用率。即这部分数据会根据对象的状态来分配存储空间。

    对象的类型指针

    即指向对象的类元数据的指针。虚拟机可以通过该指针判定对象实例属于哪个类。

    在Java对象中比较特殊的是Java数组,一个数组实例的对象头中必须记录数组的长度。JVM可以通过对象头中的数组长度数据来判定数组的大小,这是访问数组类型的元数据无法得到的。

    对象的实例数据

    前面提到对象头是对象的额外开销,只有实例数据才是一个对象实例存储的有效信息,也是在程序代码中所定义的各种类型的字段内容。这部分内容同时记录了子类从父类继承所得的各类型数据。

    填充

    对齐填充在对象数据中并不是必然的,只是起着占位符的作用,没有特别含义。HotSpot要求对象起始地址必须是8字节的整数倍。对象头的大小刚好符合要求,因此当实例数据没有对齐时,就需要通过填充来对齐数据。

    获取类的元数据

    虚拟机在加载类的时候会将类的信息、常量、静态变量和即时编译器编译后的代码等数据存储在方法区(Method Area)。类的元数据,即类的数据描述,也被存在方法区。我们知道对象头中会存有对象的类型指针,通过类型指针可以获取类的元数据。因此,对象的类型指针其实指向的是方法区的某个存有类信息的地址。

    但是,并不是每个对象实例都存有对象的类型指针。根据对象访问定位方法的不同,对象的类型指针被存放在不同的区域。

    • 通过句柄访问对象
      • 对象的类型指针被存放在句柄池中;
    • 通过Reference指针直接访问对象
      • 对象的类型指针被存放在对象本身的数据中。

    比较来说:

    • 使用句柄访问的最大好处就是reference中存储的是稳定的句柄地址,当对象被移动(垃圾收集时会经常移动对象)时智慧改变句柄中实例数据执政,而reference本身不需要修改。
    • 使用直接指针访问方式的最大好处就是速度快,节省了一次指针定位的时间开销(对象的访问在java中也非常频繁)

    因此,Java的对象数据存储可以理解为:

    • 引用类型(指向对象的Reference)
      • 存储在栈中
    • 对象的类的元数据 (Class MetaData)
      • 存储在方法区中
    • 对象的实例数据
      • 存储在堆中

    对象内存布局

    • 存储的是与对象本身定义的数据无关的额外存储成本,其数据结构不固定。
    • 32位JVM中,对象不同装填的mark word各个比特位区间图示如下:

    对象五种状态:无锁态、轻量级锁、重量级锁、GC标记和偏向锁。

    HotSpot中对象头主要包含两部分

    第一:

    用于存储对象自身的运行时数据,如上表中的对象哈希码,对象分代年龄,偏向线程id,偏向时间戳等。

    第二:

    类型指针了,我们看表中也有指针字样,那么这部分主要就是杜希昂指向它的类元数据的指针了,虚拟机就是通过这个指针来确定这个对象时那个实例。

    偏向锁和重量级锁

    • 偏向锁:主要解决无竞争下的锁性能问题
      • 按照HotSpot设计,每次加锁/解锁都会涉及到一些CAS操作,CAS操作会延迟本地调用
      • 偏向锁会偏向第一个访问锁的程序,如果接下来的运行过程中,该锁没有被其他线程访问,则持有偏向锁的线程将永远不需要触发同步。
      • 但是如果在运行过程中,遇到了其他线程抢占锁,则持有偏向锁的线程会被挂起,JVM会尝试消除它身上的偏向锁,将锁恢复到标准的轻量级锁
      • 只能在单线程中起作用
    • 轻量级锁:为了在无多线程竞争的环境中使用CAS来替代synchronized。减少传统的重量级锁使用操作系统互斥量产生的性能消耗,是为了减少多线程进入互斥的几率。并非替代互斥。

    参考资料:

    《深入理解Java虚拟机》

    http://www.cnblogs.com/chenyangyao/p/5245669.html

    深入理解多线程(二)—— Java的对象模型-HollisChuang's Blog

    深入理解多线程(三)—— Java的对象头-HollisChuang's Blog

     

    展开全文
  • java对象与json对象间的相互转换

    万次阅读 2019-02-11 15:51:59
    Java单个对象和List对象转换成Json,Json转List 可查看上一篇文章:https://blog.csdn.net/qq_36411874/article/details/83114337 目录 备注:格式化检测json网址: 备注:导入的jar包 1.简...
  • Java对象内存大小计算

    万次阅读 2018-07-03 14:43:34
    最近在读《深入理解Java虚拟机》,对Java对象的内存布局有了进一步的认识,于是脑子里自然而然就有一个很普通的问题,就是一个Java对象到底占用多大内存? 在网上搜到了一篇博客讲的非常好:...
  • java对象结构

    万次阅读 多人点赞 2017-04-19 22:31:57
    在HotSpot虚拟机中,对象在内存中存储的布局可以分为3块区域:对象头(Header)、实例数据(Instance Data)和对齐填充(Padding)。下图是普通对象实例与数组对象实例的数据结构: 对象头 HotSpot虚拟机的...
  • 如何计算Java对象所占内存的大小

    万次阅读 多人点赞 2018-05-24 11:42:12
    摘要:本文以如何计算Java对象占用内存大小为切入点,在讨论计算Java对象占用堆内存大小的方法的基础上,详细讨论了Java对象头格式并结合JDK源码对对象头中的协议字段做了介绍,涉及内存模型、锁原理、分代GC、OOP-...
  • JAVA对象模型

    千次阅读 2018-06-09 22:16:30
    现在我们来好好的看看Java对象模型: 几乎所有的Java对象保存在堆内存中(有例外,自行了解),在内存中Java对象包含三部分:对象头、实例数据和对齐填充。其中对象头是一个很关键的部分,因为对象头中包含锁状态...
  • map与java对象相互转换

    万次阅读 2019-01-22 17:01:21
    最近,研究map与java对象之间的相互转换,总结了5种方法: 第一种:使用org.apache.commons.beanutils转换 用到的主要jar包:commons-beanutils-1.9.3.jar //map转java对象 public static Object mapToObject...
  • //json字符串-简单对象 String jsonStr = "{\"studentName\":\"张三\",\"studentAge\":18}"; //json字符串-数组类型 String jsonArrStr = "[{\"studentName\":\"张三\",\"studentAge\":18},{\"studentName\":\"李四\...
  • Java对象数组

    万次阅读 多人点赞 2018-09-03 00:24:52
    所谓的对象数组,就是指包含了一组相关的对象,但是在对象数组的使用中一定要清楚一点:数组一定要先开辟空间,但是因为其是引用数据类型,所以数组里面的每一个对象都是null值,则在使用的时候数组中的每一个对象...
  • Java对象创建的流程

    千次阅读 2019-05-07 22:05:39
    Java对象创建的流程 文章目录Java对象创建的流程1.Java普通对象的创建1.1new指令1.2分配内存1.3初始化1.4对象的初始设置1.5\方法2.Java对象内存布局2.1对象头2.2实例数据2.3对齐填充 1.Java普通对象的创建 这里讨论...
  • Java对象的销毁

    千次阅读 2019-05-10 20:05:32
    对象使用完之后需要对其进行清除。对象的清除是指释放对象占用的内存。在创建对象时,用户必须使用 new 操作符为对象分配内存。不过,在清除对象时,由系统自动进行内存回收,不需要用户额外处理。这也是 Java 语言...
  • 浅谈一下JAVA对象,对象引用以及对象赋值

    万次阅读 多人点赞 2013-09-19 00:50:29
    浅谈一下JAVA对象,对象引用以及对象赋值   今天有班级同学问起JAVA对象的引用是什么。正好趁着这次机会,自己总结一下JAVA对象,对象引用以及对象赋值。自己总结了所看到的网上相关方面的不少帖子,整理汇总形成...
  • 解析一个Java对象占用多少内存空间

    千次阅读 2019-07-13 16:02:15
    对象所占据空间的末尾,如果有空白, 需要使用padding来补齐, 因为下一个对象的起始位置必须是4/8字节(32bit/64bit)的整数倍(这又是一种对齐)。 问题描述 一个对象具有100个属性, 与100个对象每个具有1个属性, ...
  • java对象头 MarkWord

    万次阅读 多人点赞 2019-06-05 20:41:15
    原文链接:[https://blog.csdn.net/scdn_cp/article/details/86491792#comments] 我们都知道,Java对象存储在堆(Heap)内存。那么一个Java对象到底包含什么呢?概括起来分为对象头、对象体和对齐字节...
  • 主要是实现复杂的嵌套的Java对象,也就是对象嵌套对象的复杂对象,转换成json字符串。然后就是反过来,把复杂的json字符串转换成对应的嵌套的Java对象。 先上工具类。如下。 package com.lxk.json; import ...
  • 目录 对象内存结构 没有继承的对象属性排布 有继承的对象属性排布 如何计算对象大小 创建一个含有premain()方法的Java 类。...将创建好的Java类打成一个jar包 ...当使用Class文件新建对象时,对象实例的...
  • java对象转js对象

    千次阅读 2017-05-04 20:51:04
    在js中直接使用 EL表达式表达java对象时,输出是对象的类名。没有达到我们要使用该对象的目的。比如var user= ${user};在页面上查询代码为var user=com.test.domain.user;这时候想要获取user的属性值: user.name是会...
  • 深入理解Java对象的创建过程:类的初始化与实例化

    万次阅读 多人点赞 2017-05-18 14:17:45
    在Java中,一个对象在可以被使用之前必须要被正确地初始化,这一点是Java规范规定的。...本文试图对JVM执行类初始化和实例化的过程做一个详细深入地介绍,以便从Java虚拟机的角度清晰解剖一个Java对象的创建过程。
  • Java对象和XML相互转换

    万次阅读 多人点赞 2018-08-19 13:33:40
    最近在项目中一直出现Java对象和XML之间的相互转换,一开始由于项目很庞大,我又是临时调度过去,导致在按照项目组长的要求进行写代码的同时,总是在这块云里雾里,最近才慢慢开始搞清楚项目中具体的使用缘由。...
  • 测量Java对象所占内存大小

    万次阅读 2017-12-17 00:40:22
    背景: 相信大部分人都不会关注这个问题吧,只有一些偏执狂才会抓着这些不放,我们平时写代码时经常会new ArrayList(),new String()之类的,那么这些刚new出来的对象在内存中占用多大空间呢?随着作者一起去看看吧...
  • JAVA笔记- JAVA对象数组的遍历与使用详解

    千次阅读 多人点赞 2019-05-31 17:44:31
    1- 对象数组概述 基本类型的数组:存储的元素为基本类型 int[] arr={1,2,3,4} 对象数组:存储的元素为引用类型 Student[] stus=new Student[3]; 解释:: Student代表一个自定义类 Stus数组中stus[0],stus[1],stus[2]...
  • Java对象的内存是在哪里分配的?

    千次阅读 2020-09-11 21:12:20
    对于绝大多数对象,内存的确是在堆中分配的,但是随着JIT编译器的进步、逃逸分析技术的成熟,“Java对象都是在堆中分配内存”这个结论变得不是那么绝对了。 针对Java的内存分配策略,笔者这里画了一张简图如下: 栈...
  • java对象的内存布局:对象头:包含两部分数据,一部分是运行时数据,包含了对象的hash值,GC分代年龄,锁状态,线程持有的锁,偏向锁等信息一部分是对象的类型指针,虚拟机通过这个指针确定对象是那个类的实例,如果...
  • 摘要:Java将对象序列化成为JSON格式、JSON格式反序列化为Java对象。 一:引入jackson的依赖: &lt;dependency&gt; &lt;groupId&gt;org.codehaus.jackson&lt;/groupId&gt; &lt;...
  • Java对象: List Map Person类(Java对象的JavaBean) 定义Person类的成员变量 1.List类型对象转为JSON数据: Java对象转换为JSON数据的步骤: 1声明Person类的两个对象,person1及person2,并封装成员变量...
  • JSON可以有两种格式,一种是对象格式的,另一种是数组对象, {"name":"JSON","address":"北京市西城区","age":25}//JSON的对象格式的字符串 [{"name":"JSON","address":...Student.java package cn.xxs.json; ...
  • Java对象大小内幕浅析

    万次阅读 2016-03-29 18:59:00
    最近突发奇想,忽然对Java对象的内存大小感兴趣,去网上搜集了一些资料,并且做一下整理,希望能够各位帮助。  如果:你能算出new String(“abc”)这个对象在JVM中占用内存大小(64位JDK7中压缩大小48B,未压缩大小...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,801,686
精华内容 1,520,674
关键字:

java对象

java 订阅