Java 垃圾回收机制，你知多少？？_垃圾回收是守护线程-CSDN博客

本文链接：https://blog.csdn.net/m0_53462955/article/details/120817651

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

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

介绍
在 C/C++ 中，程序员负责对象的创建和销毁。通常程序员会忽略无用对象的销毁。由于这种疏忽，在某些时候，为了创建新对象，可能没有足够的内存可用，整个程序将异常终止，导致 OutOfMemoryErrors 。
但是在 Java 中，程序员不需要关心所有不再使用的对象。垃圾回收机制自动销毁这些对象。
垃圾回收机制是守护线程的最佳示例，因为它始终在后台运行。
垃圾回收机制的主要目标是通过销毁无法访问的对象来释放堆内存。
重要条款：
无法访问的对象：如果一个对象不包含对它的任何引用，则称其为无法访问的对象。另请注意，属于隔离岛的对象也无法访问。

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

垃圾回收的资格：如果对象无法访问，则称该对象有资格进行 GC（垃圾回收）。在上图中，在 i = null 之后；堆区域中的整数对象 4 有资格进行垃圾回收。
使对象符合 GC 条件的方法
即使程序员不负责销毁无用的对象，但如果不再需要，强烈建议使对象不可访问（因此有资格进行 GC）。
通常有四种不同的方法可以使对象适合垃圾回收。
取消引用变量
重新分配引用变量
在方法内部创建的对象
隔离岛
以上所有带有示例的方法都在单独的文章中讨论：如何使对象符合垃圾收集条件

请求JVM运行垃圾收集器的方式
一旦我们使对象符合垃圾收集条件，垃圾收集器可能不会立即销毁它。每当 JVM 运行垃圾收集器程序时，只会销毁对象。但是当JVM运行Garbage Collector时，我们无法预料。
我们还可以请求 JVM 运行垃圾收集器。有两种方法可以做到：
使用 System.gc() 方法：系统类包含静态方法 gc() 用于请求 JVM 运行垃圾收集器。
使用 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

笔记：
不能保证以上两种方法中的任何一种都一定会运行垃圾收集器。
调用 System.gc() 等效于调用： Runtime.getRuntime().gc()
定稿
就在销毁对象之前，垃圾收集器调用对象的 finalize() 方法来执行清理活动。一旦 finalize() 方法完成，垃圾收集器就会销毁该对象。
finalize() 方法存在于具有以下原型的Object 类中。

protected void finalize() throws Throwable

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

笔记：
垃圾收集器而不是JVM调用的 finalize() 方法。虽然垃圾收集器是JVM的模块之一。
对象类 finalize() 方法有空实现，因此建议覆盖 finalize() 方法来处理系统资源或执行其他清理。
对于任何给定的对象， finalize() 方法永远不会被多次调用。
如果 finalize() 方法抛出未捕获的异常，则忽略该异常并终止该对象的终结。
有关 finalize() 方法的示例，请参阅Java 程序的输出第十套之垃圾收集

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

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

问：编写一个程序来创建一个名为 Employee 的类，该类具有以下数据成员。

1.一个ID，用于存储分配给每个员工的唯一ID。

2.员工姓名。

3.员工年龄。

另外，提供以下方法-

用于初始化名称和年龄的参数化构造函数。ID 应在此构造函数中初始化。
显示 ID、姓名和年龄的方法 show()。
显示下一个员工的 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 个步骤。

将引用设置为 null（即 X = Y = null;）
调用，System.gc();
调用，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();
    }
}