由深浅拷贝引发JVM内存区域思考

秒速五厘米 2023-03-12 13:28 7阅读 0赞

> Some things have no reason, but they have to be done

先来看一个浅拷贝的例子

/* clone方法实现浅拷贝 */
    public class ShallowCopy { 
        public static void main(String[] args) { 
            Age a=new Age(20);
            Student stu1=new Student("摇头耶稣",a,175);
            
      //通过调用重写后的clone方法进行浅拷贝
            Student stu2=(Student)stu1.clone();
            System.out.println(stu1.toString());
            System.out.println(stu2.toString());
            
       //尝试修改stu1中的各属性，观察stu2的属性有没有变化
            stu1.setName("大傻子");
            //改变age这个引用类型的成员变量的值
            a.setAge(99);
            //stu1.setaAge(new Age(99)); 使用这种方式修改age属性值的话，stu2是不会跟着改变的。因为创建了一个新的Age类对象而不是改变原对象的实例值
            stu1.setLength(216);
            System.out.println(stu1.toString());
            System.out.println(stu2.toString());
        }
    }
    
    /* * 创建年龄类 */
    class Age{ 
        //年龄类的成员变量（属性）
        private int age;
        //构造方法
        public Age(int age) { 
            this.age=age;
        }
        
        public int getAge() { 
            return age;
        }
        
        public void setAge(int age) { 
            this.age = age;
        }
        
        public String toString() { 
            return this.age+"";
        }
    }
    /* * 创建学生类 */
    class Student implements Cloneable{ 
        //学生类的成员变量（属性）,其中一个属性为类的对象
        private String name;
        private Age aage;
        private int length;
        //构造方法,其中一个参数为另一个类的对象
        public Student(String name,Age a,int length) { 
            this.name=name;
            this.aage=a;
            this.length=length;
        }
        //eclipe中alt+shift+s自动添加所有的set和get方法
        public String getName() { 
            return name;
        }
    
        public void setName(String name) { 
            this.name = name;
        }
        
        public Age getaAge() { 
            return this.aage;
        }
        
        public void setaAge(Age age) { 
            this.aage=age;
        }
        
        public int getLength() { 
            return this.length;
        }
        
        public void setLength(int length) { 
            this.length=length;
        }
        //设置输出的字符串形式
        public String toString() { 
            return "姓名是： "+this.getName()+"， 年龄为： "+this.getaAge().toString()+", 长度是： "+this.getLength();
        }
        //重写Object类的clone方法
        public Object clone() { 
            Object obj=null;
            //调用Object类的clone方法，返回一个Object实例
            try { 
                obj= super.clone();
            } catch (CloneNotSupportedException e) { 
                e.printStackTrace();
            }
            return obj;
        }
    }

姓名是： 摇头耶稣， 年龄为： 20, 长度是： 175  
姓名是： 摇头耶稣， 年龄为： 20, 长度是： 175  
姓名是： 大傻子， 年龄为： 99, 长度是： 216  
姓名是： 摇头耶稣， 年龄为： 99, 长度是： 175

很明显这里面有Student 类里面有name、length两个基本数据类型，**在clone时会被拷贝过去，而引用类型aage则不会**

package linearList;
    /* 层次调用clone方法实现深拷贝 */
    public class DeepCopy { 
        public static void main(String[] args) { 
            Age a=new Age(20);
            Student stu1=new Student("摇头耶稣",a,175);
            
      //通过调用重写后的clone方法进行浅拷贝
            Student stu2=(Student)stu1.clone();
            System.out.println(stu1.toString());
            System.out.println(stu2.toString());
            System.out.println();
            
       //尝试修改stu1中的各属性，观察stu2的属性有没有变化
            stu1.setName("大傻子");
            //改变age这个引用类型的成员变量的值
            a.setAge(99);
            //stu1.setaAge(new Age(99)); 使用这种方式修改age属性值的话，stu2是不会跟着改变的。因为创建了一个新的Age类对象而不是改变原对象的实例值
            stu1.setLength(216);
            System.out.println(stu1.toString());
            System.out.println(stu2.toString());
        }
    }
    
    /* * 创建年龄类 */
    class Age implements Cloneable{ 
        //年龄类的成员变量（属性）
        private int age;
        //构造方法
        public Age(int age) { 
            this.age=age;
        }
        
        public int getAge() { 
            return age;
        }
        
        public void setAge(int age) { 
            this.age = age;
        }
        
        public String toString() { 
            return this.age+"";
        }
        
        //重写Object的clone方法
        public Object clone() { 
            Object obj=null;
            try { 
                obj=super.clone();
            } catch (CloneNotSupportedException e) { 
                e.printStackTrace();
            }
            return obj;
        }
    }
    /* * 创建学生类 */
    class Student implements Cloneable{ 
        //学生类的成员变量（属性）,其中一个属性为类的对象
        private String name;
        private Age aage;
        private int length;
        //构造方法,其中一个参数为另一个类的对象
        public Student(String name,Age a,int length) { 
            this.name=name;
            this.aage=a;
            this.length=length;
        }
        public String getName() { 
            return name;
        }
    
        public void setName(String name) { 
            this.name = name;
        }
        
        public Age getaAge() { 
            return this.aage;
        }
        
        public void setaAge(Age age) { 
            this.aage=age;
        }
        
        public int getLength() { 
            return this.length;
        }
        
        public void setLength(int length) { 
            this.length=length;
        }
        public String toString() { 
            return "姓名是： "+this.getName()+"， 年龄为： "+this.getaAge().toString()+", 长度是： "+this.getLength();
        }
        //重写Object类的clone方法
        public Object clone() { 
            Object obj=null;
            //调用Object类的clone方法——浅拷贝
            try { 
                obj= super.clone();
            } catch (CloneNotSupportedException e) { 
                e.printStackTrace();
            }
            //调用Age类的clone方法进行深拷贝
            //先将obj转化为学生类实例
            Student stu=(Student)obj;
            //学生类实例的Age对象属性，调用其clone方法进行拷贝
            stu.aage=(Age)stu.getaAge().clone();
            return obj;
        }
    }

姓名是： 摇头耶稣， 年龄为： 20, 长度是： 175  
姓名是： 摇头耶稣， 年龄为： 20, 长度是： 175  
姓名是： 大傻子， 年龄为： 99, 长度是： 216  
姓名是： 摇头耶稣， 年龄为： 20, 长度是： 175

分析结果可以验证：进行了深拷贝之后，无论是什么类型的属性值的修改，都不会影响另一个对象的属性值。

*当然深拷贝还可以通过对象序列化再反序列化*

这里引发博主思考，为什么普通clone时，引用对象不会复制一份呢，这些基本数据类型的成员变量引用和变量本身到底存在哪里，引用类型又是如何呢。堆栈。。。方法区。。。emmm又忘了，不慌，我们下面来温习一下。

先图刺激一下大脑  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hrNDg0ODEyMw_size_16_color_FFFFFF_t_70]

**线程私有的：程序计数器，虚拟机栈，本地方法栈**

**线程共享的：堆，方法区，直接内存**

**1 程序计数器**  
　　程序计数器是一块较小的内存空间，可以看作是当前线程所执行的字节码的行号指示器。字节码解释器工作时通过改变这个计数器的值来选取下一条需要执行的字节码指令，分支、循环、跳转、异常处理、线程恢复等功能都需要依赖这个计数器来完。  
　　java虚拟机的多线程是通过线程轮流切换并分配CPU的时间片的方式实现的，因此在任何时刻一个处理器（如果是多核处理器，则只是一个核）都只会处理一个线程，为了线程切换后能恢复到正确的执行位置，每条线程都需要有一个独立的程序计数器，各线程之间计数器互不影响，独立存储，因此这类内存区域为“线程私有”的内存。  
　　从上面的介绍中我们知道程序计数器主要有两个作用：  
字节码解释器通过改变程序计数器来依次读取指令，从而实现代码的流程控制，如：顺序执行、选择、循环、异常处理。  
在多线程的情况下，程序计数器用于记录当前线程执行的位置，从而当线程被切换回来的时候能够知道该线程上次运行到哪儿了。  
　　`注意：程序计数器是唯不会出现 OutOfMemoryError 的内存区域，它的生命周期随着线程的创建而创建，随着线程的结束而死亡。`

**2 Java 虚拟机栈**  
　　Java虚拟机栈也是线程私有的，它的生命周期和线程相同，描述的是 Java 方法执行的内存模型。Java虚拟机栈是由一个个栈帧组成，线程在执行一个方法时，便会向栈中放入一个栈帧，每个栈帧中都拥有局部变量表、操作数栈、动态链接、方法出口信息。局部变量表主要存放了编译器可知的各种基本数据类型（boolean、byte、char、short、int、float、long、double）和对象引用（reference类型，它不同于对象本身，可能是一个指向对象起始地址的引用指针，也可能是指向一个代表对象的句柄或其他与此对象相关的位置）。  
　　Java 虚拟机栈会出现两种异常：StackOverFlowError 和 OutOfMemoryError。  
　　StackOverFlowError：若Java虚拟机栈的内存大小不允许动态扩展，那么当线程请求栈的深度超过当前Java虚拟机栈的最大深度的时候，就抛出StackOverFlowError异常。  
　　OutOfMemoryError：若 Java 虚拟机栈的内存大小允许动态扩展，且当线程请求栈时内存用完了，无法再动态扩展了，此时抛出OutOfMemoryError异常。  
　　Java 虚拟机栈也是线程私有的，每个线程都有各自的Java虚拟机栈，而且随着线程的创建而创建，随着线程的死亡而死亡。  
　　  
**3 本地方法栈**  
　　和虚拟机栈所发挥的作用非常相似，区别是： 虚拟机栈为虚拟机执行 Java 方法 （也就是字节码）服务，而本地方法栈则为虚拟机使用到的 Native 方法服务。 在 HotSpot 虚拟机中和 Java 虚拟机栈合二为一。

本地方法被执行的时候，在本地方法栈也会创建一个栈帧，用于存放该本地方法的局部变量表、操作数栈、动态链接、出口信息。方法执行完毕后相应的栈帧也会出栈并释放内存空间，也会出现 StackOverFlowError 和 OutOfMemoryError 两种异常。

*OK，针对这个本地方法栈大家应该还有迷惑的地方，再来详细说明下*

对于一个运行中的Java程序而言，它还可能会用到一些跟本地方法相关的数据区。当某个线程调用一个本地方法时，它就进入了一个全新的并且不再受虚拟机限制的世界。本地方法可以通过本地方法接口来访问虚拟机的运行时数据区，但不止如此，它还可以做任何它想做的事情。

本地方法本质上时依赖于实现的，虚拟机实现的设计者们可以自由地决定使用怎样的机制来让Java程序调用本地方法。

任何本地方法接口都会使用某种本地方法栈。当线程调用Java方法时，虚拟机会创建一个新的栈帧并压入Java栈。然而当它调用的是本地方法时，虚拟机会保持Java栈不变，不再在线程的Java栈中压入新的帧，虚拟机只是简单地动态连接并直接调用指定的本地方法。

如果某个虚拟机实现的本地方法接口是使用C连接模型的话，那么它的本地方法栈就是C栈。当C程序调用一个C函数时，其栈操作都是确定的。传递给该函数的参数以某个确定的顺序压入栈，它的返回值也以确定的方式传回调用者。同样，这就是虚拟机实现中本地方法栈的行为。

很可能本地方法接口需要回调Java虚拟机中的Java方法，在这种情况下，该线程会保存本地方法栈的状态并进入到另一个Java栈。

下图描绘了这样一个情景，就是当一个线程调用一个本地方法时，本地方法又回调虚拟机中的另一个Java方法。

这幅图展示了JAVA虚拟机内部线程运行的全景图。一个线程可能在整个生命周期中都执行Java方法，操作它的Java栈；或者它可能毫无障碍地在Java栈和本地方法栈之间跳转。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hrNDg0ODEyMw_size_16_color_FFFFFF_t_70_pic_center]  
　　该线程首先调用了两个Java方法，而第二个Java方法又调用了一个本地方法，这样导致虚拟机使用了一个本地方法栈。假设这是一个C语言栈，其间有两个C函数，第一个C函数被第二个Java方法当做本地方法调用，而这个C函数又调用了第二个C函数。之后第二个C函数又通过本地方法接口回调了一个Java方法（第三个Java方法），最终这个Java方法又调用了一个Java方法（它成为图中的当前方法）。

**4 方法区**  
方法区同堆一样，是所有线程共享的内存区域，为了区分堆，又被称为非堆。

用于存储已被虚拟机加载的类信息、常量、静态变量，如static修饰的变量加载类的时候就被加载到方法区中。

常量池

是方法区的一部分，class文件除了有`类的字段、接口、方法`等描述信息之外，还有常量池用于存放编译期间生成的各种字面量和符号引用。

在老版jdk，方法区也被称为永久代【因为没有强制要求方法区必须实现垃圾回收，HotSpot虚拟机以永久代来实现方法区，从而JVM的垃圾收集器可以像管理堆区一样管理这部分区域，从而不需要专门为这部分设计垃圾回收机制。不过自从JDK7之后，Hotspot虚拟机便将运行时常量池从永久代移除了。】  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hrNDg0ODEyMw_size_16_color_FFFFFF_t_70_pic_center 1]  
常量池细节：  
[https://blog.csdn.net/xk4848123/article/details/105915340][https_blog.csdn.net_xk4848123_article_details_105915340]

`JDK8把类的元数据放到本地堆内存（native heap）中，这一块区域就叫Metaspace，中文名叫元空间`。

**5 堆**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hrNDg0ODEyMw_size_16_color_FFFFFF_t_70 1]  
堆是JVM内存占用最大，管理最复杂的一个区域。其唯一的用途就是存放对象实例：所有的对象实例及数组都在对上进行分配。1.8后，字符串常量池从永久代中剥离出来，存放在堆中。堆有自己进一步的内存分块划分，具体划分请参见上图。

**6直接内存**  
jdk1.4引入了NIO，它可以使用Native函数库直接分配堆外内存。另外元数据也是用的直接内存。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hrNDg0ODEyMw_size_16_color_FFFFFF_t_70]: /images/20230312/ac35d2279ab44971ade1671442a7a975.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hrNDg0ODEyMw_size_16_color_FFFFFF_t_70_pic_center]: /images/20230312/a52060c6577944e18fd35b8c33e2f77b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hrNDg0ODEyMw_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20230312/1eb073fd8f93468c96a247d969c12909.png
[https_blog.csdn.net_xk4848123_article_details_105915340]: https://blog.csdn.net/xk4848123/article/details/105915340
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hrNDg0ODEyMw_size_16_color_FFFFFF_t_70 1]: /images/20230312/9266bb2a12df4b87aab390189ea8a9dc.png