调用`System.gc（）`是一种在Java应用程序中管理内存的好方法吗？

Question

I have a java application that wants to invoke the system.gc(). Is it a reasonable method to release memory? or any other advice? Really appreciate!

Answer 1

Just stop referencing the variable. You don't need to invoke System#gc() yourself. If the JVM is on an edge of an OutOfMemoryError , it will certainly run the GC.

If stopping referencing the variables is not an option because you really need them, then you need to profile your application to fix/clean any memory leaks and/or just give JVM more memory at startup.

Answer 2

In Java it is not necessary to explicitly invoke garbage collection. It is done automatically by the virtual machine.

Answer 3

Don't call System.gc() . Running the garbage collector unnecessarily is a great way to ruin the performance of your program. The JVM will collect garbage when it needs to.

One of the biggest advantages of the Java platform is successful automated garbage collection. Use it.

Answer 4

Only under very specific circumstances and after being proven by rigorous profiling, would it be a good idea to explicitly invoke gc() . It should never make a functional difference, but it might have perceived performance gains under very certain scenarios.

For example, say you were making a video game with Java and every few minutes you come to a break between levels. This might prove to be a good place to explicitly invoke the Garbage Collector if it reduces the chance that a GC cycle will occur while playing the next level (which could be disruptive to gameplay).

In short, it should be reserved for times where you know better than the runtime when the GC is most desirable, and again, it should only be used after rigorous profiling justifying its inclusion.

Answer 5

Head First Java这本书说每个变量（实例或局部变量）都有一个范围，当范围丢失时，变量就不再存在了，当谈论对象时，它说对象是垃圾收集器的最后一个实时参考消失。

Answer 6

System.gc() will begin Full Collection, which is especially bad if you care about pause times and are using the concurrent or G1 collectors.

Unless you have isolated a specific reason that you that you need different behavior, you shouldn't play with garbage collection... you will more likely hurt performance than see any gains.

Answer 7

Soft & weak references are a great way to hold onto data that you'd like to be in memory but can do without if memory gets tight.

Normal references are strong, ie an object doesn't get finalized or garbage collected while someone holds a strong reference to it. If you hold a SoftReference to an object, the object will likely stay in memory until an OutOfMemory situation when it will be automatically flushed. A WeakReference is likely to be flushed at any time but it might still be useful for occasions where holding an object saves some disk overhead.

Due to these characteristics references are great for caching data without worrying about having to flush data if the memory starts getting tight.

Easiest way to create a reference is like this:

Reference<MyClass> r = new SoftReference<MyClass>(new MyClass())

Now you pass the reference around. When you wish to obtain the object you call Reference.get()

MyClass myClass = r.get();
if (myClass != null) {
  // do something
}
else {
  // Oh dear class isn't there, go to plan b
}

Answer 8

With gc() you just say to the JRE that it should call the garbage collector. Sometimes that suggestion can be useful but in the most cases just setting all the references to the null is the right way.