电脑计算机论坛

 找回密码
 注册

QQ登录

只需一步,快速开始

查看: 442|回复: 0

Java 垃圾回收机制

[复制链接]
薛定谔的猫 发表于 2022-9-15 15:27:02 | 显示全部楼层 |阅读模式
# 面试必问:Java 垃圾回收机制

## **介绍**

- 在 C/C++ 中,程序员负责对象的创建和销毁。通常程序员会忽略无用对象的销毁。由于这种疏忽,在某些时候,为了创建新对象,可能没有足够的内存可用,整个程序将异常终止,导致 **OutOfMemoryErrors**。
- 但是在 Java 中,程序员不需要关心所有不再使用的对象。垃圾回收机制自动销毁这些对象。
- 垃圾回收机制是守护线程的最佳示例,因为它始终在后台运行。
- 垃圾回收机制的主要目标是通过销毁**无法访问的对象**来释放堆内存。



## **重要条款:**

- **无法访问的对象:** 如果一个对象不包含对它的任何引用,则称其为无法访问的对象。另请注意,属于隔离岛的对象也无法访问。

```text
Integer i = new Integer(4);
// 新的 Integer 对象可通过 'i' 中的引用访问
i = null;
// Integer 对象不再可用。
```

![img]()

- **垃圾回收的资格:** 如果对象无法访问,则称该对象有资格进行 GC(垃圾回收)。在上图中,在 *i = null 之后;* 堆区域中的整数对象 4 有资格进行垃圾回收。



## **使对象符合 GC 条件的方法**

- 即使程序员不负责销毁无用的对象,但如果不再需要,强烈建议使对象不可访问(因此有资格进行 GC)。
- 通常有四种不同的方法可以使对象适合垃圾回收。

1. 取消引用变量
2. 重新分配引用变量
3. 在方法内部创建的对象
4. 隔离岛

以上所有带有示例的方法都在单独的文章中讨论:如何使对象符合垃圾收集条件



## **请求 JVM 运行垃圾收集器的方式**

- 一旦我们使对象符合垃圾收集条件,垃圾收集器可能不会立即销毁它。每当 JVM 运行垃圾收集器程序时,只会销毁对象。但是当 JVM 运行 Garbage Collector 时,我们无法预料。
- 我们还可以请求 JVM 运行垃圾收集器。有两种方法可以做到:

1. **使用 \*System.gc()\* 方法**:系统类包含静态方法 *gc()* 用于请求 JVM 运行垃圾收集器。
2. **使用 \*Runtime.getRuntime().gc()\* 方法**:运行时类允许应用程序与运行应用程序的 JVM 交互。因此,通过使用其 gc () 方法,我们可以请求 JVM 运行垃圾收集器。

```text
// 演示请求 JVM 运行垃圾收集器的 Java 程序
public class Test
{
        public static void main(String[] args) throws InterruptedException
        {
                Test t1 = new Test();
                Test t2 = new Test();

                // 取消引用变量
                t1 = null;

                // 请求 JVM 来运行垃圾收集器
                System.gc();

                // 取消引用变量
                t2 = null;

                // 请求 JVM 来运行垃圾收集器
                Runtime.getRuntime().gc();

        }

        @Override
        // 在垃圾回收之前,在对象上调用一次 finalize 方法
        protected void finalize() throws Throwable
        {
                System.out.println("垃圾收集器调用");
                System.out.println("对象垃圾收集:" + this);
        }
}
```

输出:

```text
垃圾收集器调用
对象垃圾收集:haiyong.Test@7ad74083
垃圾收集器调用
对象垃圾收集:haiyong.Test@7410a1a9
```

**笔记 :**

1. 1. 不能保证以上两种方法中的任何一种都一定会运行垃圾收集器。
   2. 调用 *System.gc()* 等效于调用:*Runtime.getRuntime().gc()*

**定稿**

- 就在销毁对象之前,垃圾收集器调用对象的 *finalize()* 方法来执行清理活动。一旦 *finalize()* 方法完成,垃圾收集器就会销毁该对象。
- *finalize()* 方法存在于具有以下原型的 Object 类中。

```text
protected void finalize() throws Throwable
```

根据我们的要求,我们可以覆盖 *finalize()* 方法来执行我们的清理活动,例如关闭数据库连接。

**笔记 :**

1. 垃圾收集器而不是 JVM 调用的 *finalize()* 方法。虽然垃圾收集器是 JVM 的模块之一。
2. 对象类 *finalize()* 方法有空实现,因此建议覆盖 *finalize()* 方法来处理系统资源或执行其他清理。
3. 对于任何给定的对象,*finalize()* 方法永远不会被多次调用。
4. 如果 *finalize()* 方法抛出未捕获的异常,则忽略该异常并终止该对象的终结。

以上环境博主都是部署在cnaaa服务器(cnaaa.com)上的,感兴趣的伙伴可以自己部署相关的环境进行测试。有关 *finalize()* 方法的示例,请参阅 Java 程序的输出第十套之垃圾收集

**让我们举一个真实的例子,在那里我们使用垃圾收集器的概念。**

假设你去字节跳动实习,他们告诉你写一个程序,计算在公司工作的员工人数(不包括实习生)。要制作这个程序,你必须使用垃圾收集器的概念。

这是您在公司获得的实际任务:-

**问:** 编写一个程序来创建一个名为 Employee 的类,该类具有以下数据成员。
\1. 一个 ID,用于存储分配给每个员工的唯一 ID。
\2. 员工姓名。
\3. 员工年龄。

另外,提供以下方法 -

1. 用于初始化名称和年龄的参数化构造函数。ID 应在此构造函数中初始化。
2. 显示 ID、姓名和年龄的方法 show ()。
3. 显示下一个员工的 ID 的方法 showNextId ()。

现在对垃圾回收机制不了解的初学者可能会这样编写代码:

```text
//计算在公司工作的员工人数的程序

class Employee
{
        private int ID;
        private String name;
        private int age;
        private static int nextId=1;
        //它是静态的,因为它在所有对象之间保持通用并由所有对象共享
        public Employee(String name,int age)
        {
                this.name = name;
                this.age = age;
                this.ID = nextId++;
        }
        public void show()
        {
                System.out.println
                ("Id="+ID+"\nName="+name+"\nAge="+age);
        }
        public void showNextId()
        {
                System.out.println
                ("Next employee id will be="+nextId);
        }
}
class UseEmployee
{
        public static void main(String []args)
        {
                Employee E=new Employee("GFG1",33);
                Employee F=new Employee("GFG2",45);
                Employee G=new Employee("GFG3",25);
                E.show();
                F.show();
                G.show();
                E.showNextId();
                F.showNextId();
                G.showNextId();

                        { //这是保留所有实习生的子块。
                        Employee X=new Employee("GFG4",23);       
                        Employee Y=new Employee("GFG5",21);
                        X.show();
                        Y.show();
                        X.showNextId();
                        Y.showNextId();
                }
                //这个大括号之后,X 和 Y 将被移除。因此现在它应该显示 nextId 为 4。
                E.showNextId();//这一行的输出应该是 4,但它会给出 6 作为输出。
        }
}
```

**现在获得正确的输出:**

现在垃圾收集器(gc)将看到 2 个空闲的对象。现在递减 nextId,gc (garbage collector) 只会在我们的程序员在我们的类中覆盖它时调用方法 finalize () 。如前所述,我们必须请求 gc (garbage collector),为此,我们必须在关闭子块的大括号之前编写以下 3 个步骤。

1. 将引用设置为 null(即 X = Y = null;)
2. 调用,System.gc ();
3. 调用,System.runFinalization ();

现在计算员工人数的正确代码(不包括实习生)

```text
// 计算不包括实习生的员工人数的正确代码
class Employee
{
        private int ID;
        private String name;
        private int age;
        private static int nextId=1;
        //它是静态的,因为它在所有对象之间保持通用并由所有对象共享
        public Employee(String name,int age)
        {
                this.name = name;
                this.age = age;
                this.ID = nextId++;
        }
        public void show()
        {
                System.out.println
                ("Id="+ID+"\nName="+name+"\nAge="+age);
        }
        public void showNextId()
        {
                System.out.println
                ("Next employee id will be="+nextId);
        }
        protected void finalize()
        {
                --nextId;
                //在这种情况下,gc 会为 2 个对象调用 finalize() 两次。
        }
}

// 它是 Employee 类的右括号
class UseEmployee
{
        public static void main(String []args)
        {
                Employee E=new Employee("GFG1",33);
                Employee F=new Employee("GFG2",45);
                Employee G=new Employee("GFG3",25);
                E.show();
                F.show();
                G.show();
                E.showNextId();
                F.showNextId();
                G.showNextId();

                {
                        //这是保留所有实习生的子块。
                        Employee X=new Employee("GFG4",23);       
                        Employee Y=new Employee("GFG5",21);
                        X.show();
                        Y.show();
                        X.showNextId();
                        Y.showNextId();
                        X = Y = null;
                        System.gc();
                        System.runFinalization();
                }
        E.showNextId();
        }
}
```

您需要登录后才可以回帖 登录 | 注册

本版积分规则


QQ|手机版|小黑屋|电脑计算机论坛 ( 京ICP备2022023538号-1 )

GMT+8, 2024-3-29 23:16 , Processed in 0.072728 second(s), 20 queries .

Powered by Discuz! X3.5

© 2001-2024 Discuz! Team.

快速回复 返回顶部 返回列表