java内存管理关系及内存泄露原理

比眉伴天荒 2022-05-10 13:48 225阅读 0赞

这可能是最近写的博客中最接近底层的了。闲言少叙，进入正题。

## java对象和内存的关系 ##

首先，我们要知道下面几条真理（自己总结的）

1.  **一个完整的建立对象流程是 1声明对象，2开辟内存空间，3将对象和内存空间建立联系。**
2.  **一个对象只能对应一个内存空间，一个内存空间可以对应很多对象**
3.  **回收一个内存空间 。如果，这个内存空间没有任何一个对象和他有联系。就可以被回收，或者好几个对象环形引用，也会被回收**
4.  **对一个对象进行操作的时候，是先通过 对象 找到 内存空间，然后 对内存空间进行操作（读，写 改 删）**

这是本人总结出来的四条经验。  
**特别重要的是，一定要有这种认知。不管任何语言，最终都是要物理内存上面反映的，对象 和 内存空间 是两个不同的个体。** 如果 没有的话，那么你会发现 下面将的都是什么啊！

## 创建对象 ##

Stu one; //只声明 one对象 但是没有分配内存空间
    
            //用new 开辟新的内存空间 oneMemory ，调用构造函数赋值,并将内存空间 oneMemory 与 one对象建立联系。
            one = new Stu("one");
            
            //声明 two对象 并开辟内存 twoMemory 调用构造函数赋值,并将内存空间 twoMemory与 two对象建立联系
            Stu two = new Stu("two");
            
            //声明 three对象， 并找到one 对象联系的内存空间 oneMemory。并将 oneMemory与 three 对象建立联系
            Stu three = one;
            
            //此时 内存空间 oneMemory 与两个对象有联系。一个是 one对象，一个是three对象
            System.out.println("three 和 one 是否相等" + (three == one) + " one的哈希值" + one.hashCode() + " three的哈希值" + three.hashCode());

**运行结果**  
![在这里插入图片描述][70]  
我们可以发现，three对象 和one对象 指向的是同一个内存空间oneMemory。**这个不就是符合上面所说的第二个真理**  
如果，我们对one对象进行操作，那么产生的影响，也会反映到three对象上。 因为，\*\*他们指向的是同一个内存空间，对one对象操作，就是做内存空间oneMemory进行操作。而three对象指向的也是oneMemory。这个符合上面第四条真理。\*\*例子如下

System.out.println("three 对象的值" + three.getName() + three.hashCode());
    
            //修改one的值，第一步 找到one对象联系的内存空间 oneMemory ， 将内存空间oneMemory 中的name值改变
            one.setName("change");
            //读取three对象值时候，先找到three对象联系的内存空间oneMemory，读取其中的name值
            System.out.println("three 对象的值" + three.getName() + three.hashCode());

## null的作用 ##

长久以来，我只知道，将一个值复制成null，那么他就是空的了。但是 完全不知道，为啥。  
还是接着上面的例子，看一段代码；

//读取three对象值时候，先找到three对象联系的内存空间oneMemory，读取其中的name值
            System.out.println("three 对象的值 before" + three.getName() + three.hashCode());
    
            /* 此时 如果 我们把one 对象 设置为null的。 对内存空间 oneMemory 是没有影响的 =null的作用是 将one对象自己本身 对内存空间的联系去除，并不会影响到内存空间和其他对象的联系 */
            one = null;
            System.out.println("three 对象的值 after" + three.getName() + three.hashCode());

**运行结果**  
![在这里插入图片描述][70 1]  
我们会发现 将one对象赋值为空后，three对象还是和先前一样。以前一直认为null，是将对象和他的内存空间清楚。但现在不是！。代码注释里面写的很清楚了。**null 并不是清除内存空间，他只是把对象自己本身和内存空间的联系切断了**

## 内存泄露 ##

如果，你明白了上面。那么内存泄露对你来说也很简单了。  
再来学习一个新概念  
![在这里插入图片描述][70 2]

上面这么多呢。在本篇文章里面，**你只需要记住 被static关键词修饰的变量，类，方法的生命周期是伴随整个程序的。就是程序活多久，他们就活多久**  
接下来看代码  
首先，我们定义一个静态集合 staticList ，他是程序一运行，就会被创建好的。程序结束运行了，它才会被回收。

static List<Stu> staticList = new ArrayList<>();//开辟内存空间 listMemory

System.out.println("three 对象的值 after" + three.getName() + three.hashCode());
    
    
            /* 内存泄露 是长生命周期的对象 对一个内存空间有联系，造成内存空间没有办法被回收 */
    
            /* 将three对象添加到静态集合里面，步骤是这样的， 第一步 找到three对象联系的内存空间 oneMemory 第二步 找到 staticList集合对象联系的内存空间 listMemory 第三步 告诉系统 staticList集合对象的部分成员 和内存空间 oneMemory 建立联系。 */
            staticList.add(three);
            
            /* 在这里 即使three对象已经和内存空间 oneMemory 没有联系了。 oneMemory 也不会被回收，因为上面说了内存空间和对象的关系是1对多。 而回收的条件是 一个内存空间没有一条和对象的联系才可以回收。 此时 内存空间 和staticList集合对象的部分成员 有联系，所以 内存空间不会被回收。 又由于staticList 集合对象联系的内存空间在 静态存储区，是伴随整个程序的。所以 在整个程序生命里面， 内存空间 oneMemory 就得不到 回收。 就是内存泄露了。 */
            three = null;
    
            System.out.println(staticList.get(0).hashCode());

运行结果  
![在这里插入图片描述][70 3]  
可以看见。**在我们将three对象赋值null切断和内存空间 oneMemory的联系后。静态集合staticList对象的部分成员依然和内存空间 oneMemory有联系。根据上面第三条所说，因为内存空间 oneMemory 还是和对象有联系的（staticList）。所以不会回收oneMemory内存空间。又由于staticList是静态的，生命和程序一样长。** 那么在整个程序周期里面，oneMemory内存空间 都不会被回收。就造成了内存泄露。

附上完整的代码

package com.zfh.test;
    
    import java.util.ArrayList;
    import java.util.List;
    
    public class JavaMain { 
        static List<Stu> staticList = new ArrayList<>();//开辟内存空间 listMemory
    
        public static void main(String[] args) { 
    
            Stu one; //只声明 one对象 但是没有分配内存空间
    
            //用new 开辟新的内存空间 oneMemory ，调用构造函数赋值,并将内存空间 oneMemory 与 one对象建立联系。
            one = new Stu("one");
    
            //声明 two对象 并开辟内存 twoMemory 调用构造函数赋值,并将内存空间 twoMemory与 two对象建立联系
            Stu two = new Stu("two");
    
            //声明 three对象， 并找到one 对象联系的内存空间 oneMemory。并将 oneMemory与 three 对象建立联系
            Stu three = one;
    
            //此时 内存空间 oneMemory 与两个对象有联系。一个是 one对象，一个是three对象
            System.out.println("three 和 one 是否相等" + (three == one) + " one的哈希值" + one.hashCode() + " three的哈希值" + three.hashCode());
    
            System.out.println("three 对象的值" + three.getName() + three.hashCode());
    
            //修改one的值，第一步 找到one对象联系的内存空间 oneMemory ， 将内存空间oneMemory 中的name值改变
            one.setName("change");
    
            //读取three对象值时候，先找到three对象联系的内存空间oneMemory，读取其中的name值
            System.out.println("three 对象的值 before" + three.getName() + three.hashCode());
    
            /* 此时 如果 我们把one 对象 设置为null的。 对内存空间 oneMemory 是没有影响的 =null的作用是 将one对象自己本身 对内存空间的联系去除，并不会影响到内存空间和其他对象的联系 */
            one = null;
            System.out.println("three 对象的值 after" + three.getName() + three.hashCode());
    
    
            /* 内存泄露 是长生命周期的对象 对一个内存空间有联系，造成内存空间没有办法被回收 */
    
            /* 将three对象添加到静态集合里面，步骤是这样的， 第一步 找到three对象联系的内存空间 oneMemory 第二步 找到 staticList集合对象联系的内存空间 listMemory 第三步 告诉系统 staticList集合对象的部分成员 和内存空间 oneMemory 建立联系。 */
            staticList.add(three);
    
            /* 在这里 即使three对象已经和内存空间 oneMemory 没有联系了。 oneMemory 也不会被回收，因为上面说了内存空间和对象的关系是1对多。 而回收的条件是 一个内存空间没有一条和对象的联系才可以回收。 此时 内存空间 和staticList集合对象的部分成员 有联系，所以 内存空间不会被回收。 又由于staticList 集合对象联系的内存空间在 静态存储区，是伴随整个程序的。所以 在整个程序生命里面， 内存空间 oneMemory 就得不到 回收。 就是内存泄露了。 */
            three = null;
    
            System.out.println(staticList.get(0).hashCode());
    
        }
    }

bean对象 即Stu

package com.zfh.test;
    
    public class Stu { 
    
      /* static { System.out.println("静态代码块 我只调用一次"); }*/
      
        private String name;
        
      /* { System.out.println("构造代码块"); }*/
      
        public Stu(String name) { 
            this.name = name;
        }
    
        public String getName() { 
            return name;
    
        }
    
        public void setName(String name) { 
            this.name = name;
        }
    
        public void sout(){ 
            System.out.println(this.name+this.hashCode());
        }
    
        public void printer() { 
            System.out.println(Stu.class.hashCode());
        }
    
        @Override
        protected void finalize() throws Throwable { 
            super.finalize();
            System.out.println("终结了");
        }
    }

**如果，你认为我的有错误，欢迎在下方评论**

[70]: /images/20220505/48921a9e9f1d4fdbb0b7a982e7f3c2a5.png
[70 1]: /images/20220505/236b17fc5d884463978c5c79f8ce680c.png
[70 2]: /images/20220505/6c2d99b316c54e048ab80c43e1c04f4b.png
[70 3]: /images/20220505/b283237d5f714814bf4c1aad5b0cfb1c.png