当前位置：文江博客话题详情

NULL Java garbage-collection

Java 中将对象赋值为 null 会影响垃圾回收吗？

发布于 2024-07-12 02:51:10 字数 165 浏览 4 评论 0 原文

在 Java 中将未使用的对象引用分配给 null 是否可以以任何可衡量的方式改进垃圾收集过程？

我使用 Java（和 C#）的经验告诉我，尝试智胜虚拟机或 JIT 编译器通常是违反直觉的，但我见过同事使用这种方法，我很好奇这是否是一个好的做法或者那些巫术编程迷信之一？

原文

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

半城柳色半声笛 2024-07-19 02:51:10

通常情况下，不会。

但就像所有事情一样：这取决于情况。如今，Java 中的 GC 非常好，所有内容在无法再访问后都应该很快被清理掉。这是在为局部变量留下方法之后，并且不再为字段引用类实例时。

如果您知道否则将保持引用状态，则只需显式将其设置为 null。例如，保留的数组。当不再需要数组中的各个元素时，您可能希望将其清空。

例如，ArrayList 中的以下代码：

public E remove(int index) {
    RangeCheck(index);

    modCount++;
    E oldValue = (E) elementData[index];

    int numMoved = size - index - 1;
    if (numMoved > 0)
         System.arraycopy(elementData, index+1, elementData, index,
             numMoved);
    elementData[--size] = null; // Let gc do its work

    return oldValue;
}

此外，只要不保留任何引用，显式清空对象不会导致对象比自然超出范围的对象更快地被收集。

void foo() {
   Object o = new Object();
   /// do stuff with o
}

和:

void foo() {
   Object o = new Object();
   /// do stuff with o
   o = null;
}

在功能上是等效的。

Typically, no.

But like all things: it depends. The GC in Java these days is VERY good and everything should be cleaned up very shortly after it is no longer reachable. This is just after leaving a method for local variables, and when a class instance is no longer referenced for fields.

You only need to explicitly null if you know it would remain referenced otherwise. For example an array which is kept around. You may want to null the individual elements of the array when they are no longer needed.

For example, this code from ArrayList:

public E remove(int index) {
    RangeCheck(index);

    modCount++;
    E oldValue = (E) elementData[index];

    int numMoved = size - index - 1;
    if (numMoved > 0)
         System.arraycopy(elementData, index+1, elementData, index,
             numMoved);
    elementData[--size] = null; // Let gc do its work

    return oldValue;
}

Also, explicitly nulling an object will not cause an object to be collected any sooner than if it just went out of scope naturally as long as no references remain.

Both:

void foo() {
   Object o = new Object();
   /// do stuff with o
}

and:

void foo() {
   Object o = new Object();
   /// do stuff with o
   o = null;
}

Are functionally equivalent.

回复收藏 0 原文

分開簡單 2024-07-19 02:51:10

根据我的经验，人们常常出于偏执而不是出于必要而取消引用。以下是一个快速指南：

如果对象 A 引用对象 B 并且您不再需要此引用并且对象 A 不符合垃圾回收条件，那么您应该显式 null出场。如果封闭对象无论如何都会被垃圾回收，则无需清空字段。在 dispose() 方法中清空字段几乎总是无用的。
无需将方法中创建的对象引用置空。一旦方法终止，它们将自动清除。此规则的例外情况是，如果您正在运行一个很长的方法或某个大型循环，并且您需要确保在该方法结束之前清除一些引用。同样，这些情况极为罕见。

我想说的是，绝大多数时候你不需要取消引用。试图智取垃圾收集器是没有用的。你最终只会得到低效、不可读的代码。

回复收藏 0 原文

×眷恋的温暖 2024-07-19 02:51:10

好文章是今天的编码恐怖。

GC 的工作方式是查找没有任何指针的对象，其搜索区域是堆/堆栈以及它们拥有的任何其他空间。因此，如果将变量设置为 null，则实际对象现在不会被任何人指向，因此可能会被 GC 回收。

但由于 GC 可能不会在那一刻运行，因此您实际上可能不会给自己购买任何东西。但是，如果您的方法相当长（就执行时间而言），那么可能是值得的，因为您将增加 GC 收集该对象的机会。

代码优化也可能使问题变得复杂，如果在将变量设置为 null 后不再使用该变量，则删除将值设置为 null 的行（少执行一条指令）将是一种安全的优化。所以你实际上可能没有得到任何改进。

总而言之，是的，它可以提供帮助，但它不是确定性的。

回复收藏 0 原文

沫离伤花 2024-07-19 02:51:10

至少在java中，它根本不是巫术编程。当您使用类似的方法在 java 中创建对象时，您

Foo bar = new Foo();

会执行两件事：首先，创建对对象的引用，其次，创建 Foo 对象本身。只要该引用或另一个引用存在，就无法对特定对象进行垃圾回收。但是，当您将 null 分配给该引用时...

bar = null ;

并假设没有其他任何东西具有对该对象的引用，则该对象将被释放并可在垃圾收集器下次经过时用于 gc。

At least in java, it's not voodoo programming at all. When you create an object in java using something like

Foo bar = new Foo();

you do two things: first, you create a reference to an object, and second, you create the Foo object itself. So long as that reference or another exists, the specific object can't be gc'd. however, when you assign null to that reference...

bar = null ;

and assuming nothing else has a reference to the object, it's freed and available for gc the next time the garbage collector passes by.

回复收藏 0 原文

邮友 2024-07-19 02:51:10

这取决于。

一般来说，您保留对对象的引用的时间越短，它们被收集的速度就越快。

如果您的方法需要 2 秒才能执行，并且在方法执行一秒后您不再需要对象，则清除对它的任何引用是有意义的。如果 GC 在一秒钟后发现您的对象仍然被引用，下次它可能会在一分钟左右检查它。

无论如何，默认情况下将所有引用设置为 null 对我来说是过早的优化，没有人应该这样做，除非在特定的罕见情况下它可以显着减少内存消耗。

回复收藏 0 原文

多谢你的绝情让我学会死心 2024-07-19 02:51:10

显式设置对 null 的引用而不只是让变量超出范围，对垃圾收集器没有帮助，除非保存的对象非常大，在完成处理后立即将其设置为 null 是一个好主意。

一般将引用设置为null，对于代码的读者来说意味着该对象已经完全完成并且不应该再关心了。

通过放入一组额外的大括号来引入更窄的范围，可以实现类似的效果，

{
  int l;
  {  // <- here
    String bigThing = ....;
    l = bigThing.length();
  }  // <- and here
}

这允许在离开嵌套大括号后立即对 bigThing 进行垃圾收集。

Explicitly setting a reference to null instead of just letting the variable go out of scope, does not help the garbage collector, unless the object held is very large, where setting it to null as soon as you are done with is a good idea.

Generally setting references to null, mean to the READER of the code that this object is completely done with and should not be concerned about any more.

A similar effect can be achieved by introducing a narrower scope by putting in an extra set of braces

{
  int l;
  {  // <- here
    String bigThing = ....;
    l = bigThing.length();
  }  // <- and here
}

this allows the bigThing to be garbage collected right after leaving the nested braces.

回复收藏 0 原文

梦里梦着梦中梦 2024-07-19 02:51:10

public class JavaMemory {
    private final int dataSize = (int) (Runtime.getRuntime().maxMemory() * 0.6);

    public void f() {
        {
            byte[] data = new byte[dataSize];
            //data = null;
        }

        byte[] data2 = new byte[dataSize];
    }

    public static void main(String[] args) {

        JavaMemory jmp = new JavaMemory();
        jmp.f();

    }

}

上面的程序抛出OutOfMemoryError。如果取消注释 data = null;，OutOfMemoryError 就会得到解决。将未使用的变量设置为 null 始终是一个好习惯

public class JavaMemory {
    private final int dataSize = (int) (Runtime.getRuntime().maxMemory() * 0.6);

    public void f() {
        {
            byte[] data = new byte[dataSize];
            //data = null;
        }

        byte[] data2 = new byte[dataSize];
    }

    public static void main(String[] args) {

        JavaMemory jmp = new JavaMemory();
        jmp.f();

    }

}

Above program throws OutOfMemoryError. If you uncomment data = null;, the OutOfMemoryError is solved. It is always good practice to set the unused variable to null

回复收藏 0 原文

脱离于你 2024-07-19 02:51:10

有一次，我正在开发一个视频会议应用程序，当我不再需要该对象时，我花时间将引用设为空引用，结果发现性能存在巨大差异。那是在 2003-2004 年，我只能想象自那以后 GC 变得更加智能。就我而言，每秒都有数百个对象进出范围，因此当 GC 定期启动时，我注意到了它。然而，在我将其指向空对象后，GC 停止暂停我的应用程序。

所以这取决于你做什么...

回复收藏 0 原文

つ低調成傷 2024-07-19 02:51:10

我假设OP指的是这样的事情：

private void Blah()
{
    MyObj a;
    MyObj b;

    try {
        a = new MyObj();
        b = new MyObj;

        // do real work
    } finally {
        a = null;
        b = null;
    }
}

在这种情况下，VM不会在它们离开作用域时立即将它们标记为GC吗？

或者，从另一个角度来看，显式地将这些项设置为 null 是否会导致它们在超出范围时先被 GC 处理？如果是这样，当无论如何都不需要内存时，VM 可能会花费时间来 GC 对象，这实际上会导致 CPU 使用性能更差，因为它会更早地进行 GC 。

I assume the OP is referring to things like this:

private void Blah()
{
    MyObj a;
    MyObj b;

    try {
        a = new MyObj();
        b = new MyObj;

        // do real work
    } finally {
        a = null;
        b = null;
    }
}

In this case, wouldn't the VM mark them for GC as soon as they leave scope anyway?

Or, from another perspective, would explicitly setting the items to null cause them to get GC'd before they would if they just went out of scope? If so, the VM may spend time GC'ing the object when the memory isn't needed anyway, which would actually cause worse performance CPU usage wise because it would be GC'ing more earlier.

回复收藏 0 原文

世界和平 2024-07-19 02:51:10

即使取消引用稍微更有效，是否值得在代码中添加这些丑陋的取消？它们只会变得混乱并模糊包含它们的意图代码。

它是一个罕见的代码库，没有比试图智胜垃圾收集器更好的优化候选者（更罕见的是成功智胜垃圾收集器的开发人员）。您的努力很可能会更好地花在其他地方，放弃那个粗俗的 Xml 解析器或寻找一些缓存计算的机会。这些优化将更容易量化，并且不需要您用噪音弄脏您的代码库。

回复收藏 0 原文

恬淡成诗 2024-07-19 02:51:10

是的。

来自“务实程序员”第 292 页：

通过设置对 NULL 的引用，可以将指向该对象的指针数量减少一......（这将允许垃圾收集器将其删除）

回复收藏 0 原文

眉目亦如画i 2024-07-19 02:51:10

“这取决于”

我不了解 Java，但在 .net（C#、VB.net...）中，当您不再需要对象时，通常不需要分配 null。

但请注意，“通常不需要”。

通过分析您的代码，.net 编译器可以很好地评估变量的生命周期...以准确判断对象何时不再被使用。因此，如果你写 obj=null ，它实际上看起来好像 obj 仍在使用......在这种情况下，分配 null 会适得其反。

在某些情况下，分配 null 实际上可能会有所帮助。一个例子是，您有一段运行很长时间的庞大代码，或者一个在不同线程或某个循环中运行的方法。在这种情况下，分配 null 可能会有所帮助，以便 GC 很容易知道它不再被使用。

没有硬性的& 对此的快速规则。按照上面的方法，在代码中进行空分配，并运行分析器以查看它是否有任何帮助。您很可能看不到任何好处。

如果您要优化的是 .net 代码，那么我的经验是，认真对待 Dispose 和 Finalize 方法实际上比担心 null 更有益。

有关该主题的一些参考：

http://blogs.msdn。 com/csharpfaq/archive/2004/03/26/97229.aspx

http://weblogs.asp.net/pwilson/archive/2004/02/20/77422.aspx

回复收藏 0 原文

以为你会在 2024-07-19 02:51:10

在将来执行程序时，某些数据成员的值将用于计算程序外部可见的输出。其他可能会也可能不会被使用，取决于未来（并且无法预测）程序的输入。其他数据成员可能保证不被使用。分配给那些未使用的数据的所有资源（包括内存）都被浪费了。垃圾收集器 (GC) 的工作就是消除浪费的内存。对于 GC 来说，消除一些需要的东西将是灾难性的，因此所使用的算法可能是保守的，保留的数量超过了严格的最小值。它可能会使用启发式优化来提高速度，但代价是保留一些实际不需要的项目。 GC 可能使用许多潜在的算法。因此，您对程序所做的更改可能不会影响程序的正确性，但可能会影响 GC 的操作，要么使其运行得更快以完成相同的工作，要么更快地识别未使用的项目。因此，这种将 unusdd 对象引用设置为 null 的更改，理论上并不总是巫术。

是巫毒吗？据报道，Java 库代码的一部分可以执行此操作。该代码的编写者比普通程序员要好得多，并且要么了解了解垃圾收集器实现细节的程序员，要么与了解垃圾收集器实现细节的程序员合作。这表明有时是有好处的。

回复收藏 0 原文

两人的回忆 2024-07-19 02:51:10

正如你所说，有一些优化，即 JVM 知道变量最后一次使用的位置，并且它引用的对象可以在最后一点之后立即被 GC（仍在当前范围内执行）。所以在大多数情况下清空引用并不能帮助GC。

但这对于避免“裙带关系”（或“浮动垃圾”）问题很有用（在此处了解更多信息或观看视频）。之所以存在这个问题，是因为堆被分为旧代和年轻代，并且应用了不同的 GC 机制：次要 GC（速度很快，经常发生在清理年轻代）和主要 GC（这会导致清理旧代的停顿时间更长）。如果年轻一代的垃圾被已经属于老一代的垃圾引用，“裙带关系”不允许收集年轻一代的垃圾。

这是“病态的”，因为任何提升的节点都会导致所有后续节点的提升，直到 GC 解决问题为止。

为了避免裙带关系，最好将应该删除的对象的引用置空。您可以在 JDK 类中看到此技术的应用：LinkedList 和 LinkedHashMap

private E unlinkFirst(Node<E> f) {
    final E element = f.item;
    final Node<E> next = f.next;
    f.item = null;
    f.next = null; // help GC
    // ...
}

As you said there are optimizations, i.e. JVM knows the place when the variable was last used and the object referenced by it can be GCed right after this last point (still executing in current scope). So nulling out references in most cases does not help GC.

But it can be useful to avoid "nepotism" (or "floating garbage") problem (read more here or watch video). The problem exists because heap is split into Old and Young generations and there are different GC mechanisms applied: Minor GC (which is fast and happens often to clean young gen) and Major Gc (which causes longer pause to clean Old gen). "Nepotism" does not allow for garbage in Young gen to be collected if it is referenced by garbage which was already tenured to an Old gen.

This is 'pathological' because ANY promoted node will result in the promotion of ALL following nodes until a GC resolves the issue.

To avoid nepotism it's a good idea to null out references from an object which is supposed to be removed. You can see this technique applied in JDK classes: LinkedList and LinkedHashMap

private E unlinkFirst(Node<E> f) {
    final E element = f.item;
    final Node<E> next = f.next;
    f.item = null;
    f.next = null; // help GC
    // ...
}

回复收藏 0 原文

拥抱我好吗 2024-07-19 02:51:10

Oracle 文档指出“将 null 分配给不再需要的变量” https://docs.oracle.com/cd/E19159-01/819-3681/abebi/index.html

回复收藏 0 原文

~没有更多了~

关于作者

GRAY°灰色天空

暂无简介

0 文章

0 评论

23 人气

关注发私信

友情链接

文江博客

Java 中将对象赋值为 null 会影响垃圾回收吗？

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

评论（15）

关于作者

相关话题

热门标签

推荐作者

qq_E2Iff7

Archangel

freedog

Hunk

18819270189

wenkai

友情链接

Java 中将对象赋值为 null 会影响垃圾回收吗？

如果你对这篇内容有疑问，欢迎到本站社区发帖提问 参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

评论（15）

关于作者

相关话题

热门标签

推荐作者

qq_E2Iff7

Archangel

freedog

Hunk

18819270189

wenkai

友情链接

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。