java garbage collection

In Java, when an object does not have any references, it becomes garbage. If it is not recycled in time and the memory is released, the garbage will accumulate more and more, and eventually out of memory!, and the JVM will stop running.

Some people are confused: We usually do not explicitly destroy objects when coding, so how can the program run well?

This is about today’s protagonist, jvm’s daemon thread GC. GC is a garbage collector. According to a certain algorithm, it releases garbage objects from time to time and defragments the memory to ensure high memory. Availability to maintain the normal operation of the process.

Let’s look at the following piece of code:

public class DemoDatatype {

public static void main(String[] args) {

new DemoDatatype();

System.gc();

System.out .println("over!");

}

@Override

protected void finalize() throws Throwable {

System.out.println("Work before garbage collection!");

super.finalize( ; ? At least the above results show that there is no recycling, because the jvm has sufficient memory and I don’t bother to work hard to recycle you. I am very resource-consuming^_^. .. Java.lang.System has a static method GC () under the class, and you can notify GC: Hi, I have garbage, come and help collect it. However, the GC may not necessarily respond to your request immediately. There may be a traffic jam halfway, and it is not clear when it will arrive. Execute gc() to see the results:

public class DemoDatatype {

public static void main(String[] args) {

new DemoDatatype();

System.gc();

System.out. println("over!");

}

@Override

protected void finalize() throws Throwable {

System.out.println("Work before garbage collection!");

super.finalize() ;

}

}

Program output: over!

Work before garbage collection!

                                         or: work before garbage collection!

                                                                                                                                                                                                                                                                                                over!

GC executes the finalize() method before garbage collection. We know that GC only knows those objects applied for through new. If some memory is opened through abnormal means, then GC will be confused.

The function of finalize() is to release some resources before garbage collection, such as some resources that cannot be recycled by gc, such as "non-new" memory, unclosed IO, etc. But be sure not to rely on finalize() to release resources. The GC may not be reachable and may cause memory leaks.

Under what circumstances will GC be triggered?

1) GC is a daemon thread. As a member of the service industry, it has the lowest priority, so it will only start when the application is idle.

2) When the memory is insufficient and the application is on the verge of death, the GC will step forward to eliminate garbage and release memory. If the memory leak is serious, the jvm will stop running.

GC work will also consume system resources. How to avoid unnecessary overhead?

1) Don’t create garbage: reduce the use of temporary objects; unavoidable, leave them empty after use

2) Don’t actively request GC: don’t explicitly call system.gc()

3) Objects with a clear life cycle, proactively Destroy

4) Avoid concentrated creation of a large number of useless objects, such as splicing a large number of strings

5) Pay attention to memory leaks during the coding process to ensure the rigor of the code.