面试必问：Java 垃圾回收机制

末蓝、 2022-08-28 11:39 173阅读 0赞

> **摘要：**垃圾回收机制是守护线程的最佳示例，因为它始终在后台运行。

本文分享自华为云社区《[一文带你了解Java 中的垃圾回收机制][Java]》，作者：海拥。

## **介绍** ##

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

## **重要条款：** ##

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

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

![2e2c787a8b40d0201506d2830b373570.png][]

*  **垃圾回收的资格：** 如果对象无法访问，则称该对象有资格进行 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 运行垃圾收集器。

// 演示请求 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);
    	}
    }

输出：

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

**笔记 ：**

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

**定稿**

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

protected void finalize() throws Throwable

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

**笔记 ：**

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

有关*finalize()* 方法的示例，请参阅Java 程序的输出第十套之垃圾收集

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

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

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

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

另外，提供以下方法-

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

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

//计算在公司工作的员工人数的程序
    
    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();

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

// 计算不包括实习生的员工人数的正确代码
    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();
    	}
    }

**[点击关注，第一时间了解华为云新鲜技术~][Link 1]**

[Java]: https://link.zhihu.com/?target=https%3A//bbs.huaweicloud.com/blogs/301144%3Futm_source%3Dzhihu%26utm_medium%3Dbbs-ex%26utm_campaign%3Dother%26utm_content%3Dcontent
[2e2c787a8b40d0201506d2830b373570.png]: /images/20220828/1349e557d1714a5b89bab040e546c42a.png
[Link 1]: https://link.zhihu.com/?target=https%3A//bbs.huaweicloud.com/blogs%3Futm_source%3Dzhihu%26utm_medium%3Dbbs-ex%26utm_campaign%3Dother%26utm_content%3Dcontent