关于java:面试必问Java-垃圾回收机制

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

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

• 在 C/C++ 中，程序员负责对象的创立和销毁。通常程序员会疏忽无用对象的销毁。因为这种忽略，在某些时候，为了创立新对象，可能没有足够的内存可用，整个程序将异样终止，导致 OutOfMemoryErrors。
• 然而在 Java 中，程序员不须要关怀所有不再应用的对象。垃圾回收机制主动销毁这些对象。
• 垃圾回收机制是守护线程的最佳示例，因为它始终在后盾运行。
• 垃圾回收机制的次要指标是通过销毁 无法访问的对象 来开释堆内存。

无法访问的对象：如果一个对象不蕴含对它的任何援用，则称其为无法访问的对象。另请留神，属于隔离岛的对象也无法访问。

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

垃圾回收的资格：如果对象无法访问，则称该对象有资格进行 GC（垃圾回收）。在上图中，在 i = null 之后；堆区域中的整数对象 4 有资格进行垃圾回收。

• 即便程序员不负责销毁无用的对象，但如果不再须要，强烈建议使对象不可拜访（因而有资格进行 GC）。
• 通常有四种不同的办法能够使对象适宜垃圾回收。

勾销援用变量
重新分配援用变量
在办法外部创立的对象
隔离岛

以上所有带有示例的办法都在独自的文章中探讨：如何使对象合乎垃圾收集条件

• 一旦咱们使对象合乎垃圾收集条件，垃圾收集器可能不会立刻销毁它。每当 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();}
}

点击关注，第一工夫理解华为云陈腐技术~

关于java:面试必问Java-垃圾回收机制

介绍

重要条款：

使对象合乎 GC 条件的办法

申请 JVM 运行垃圾收集器的形式