Shulou(Shulou.com)06/02 Report--

This article mainly explains "how to understand java garbage collector", interested friends may wish to take a look. The method introduced in this paper is simple, fast and practical. Let's take you to learn "how to understand java garbage collector"!

first introduction

For C++ programmers new to Java, understanding the relationship between stacks and heaps may be unfamiliar. In C++, objects can be created on the heap using the new operator or on the stack using automatic allocation. The following C++ statement is legal, but the Java compiler refuses to write code in this way, resulting in syntax error compilation errors.

Integer foo = Integer(1);

Java is different from C in that Java places objects on the heap and requires the new operator to create objects. Local variables are stored on the stack, and they hold a reference (pointer) to an object in the heap. Here is a Java method with an Integer variable that resolves a value from String

public static void foo(String bar){ Integer baz = new Integer(bar); }

So this code, we can use stack allocation diagrams to see how they relate.

Let's start with the foo() method, which assigns a new Integer object and the JVM tries to carve out a memory space in heap space. If allocation is allowed, the Integer constructor is called to convert the String string to an Integer object. The JVM stores a pointer to the object in the variable baz.

This is something we would love to see, since we don't want to get stuck writing code, but it's impossible to do, because OutOfMemoryError occurs when heap space can't be made available for bar and baz, and then the garbage collector is called to try to make room. This involves a question, which objects will be collected by the garbage collector?

garbage collector

Java gives you a new operator to carve up memory space for objects in the heap, but it doesn't provide a delete operator to free up object space. When the foo() method returns, if the variable baz exceeds the maximum memory, but the object it points to is still in the heap. If there is no garbage collector, the program will throw OutOfMemoryError. Java does not, however, provide garbage collectors to free objects that are no longer referenced.

The garbage collector works when a program tries to create a new object and there is not enough space in the heap. When the collector accesses the heap, the requesting thread is suspended, trying to find objects that the program no longer actively uses and reclaim their space. If the garbage collector cannot free enough memory space and the JVM cannot expand the heap, an OutOfMemoryError occurs, and your application usually crashes after that. Another case is StackOverflowError, which occurs because a thread requests a stack depth greater than the virtual machine allows.

mark-and-clear algorithm

One of the reasons Java lasts forever is because of garbage collectors. Many people think that the JVM keeps a reference count for each object, and that the reference counter is +1 each time an object is referenced, and-1 each time a reference expires. The garbage collector only collects cases where the reference counter has a value of 0. This is actually the collection method of reference Counting. However, this approach does not solve the problem of mutual references between objects, as follows

class A{ public B b; } class B{ public A a; } public class Main{ public static void main(String[] args){ A a = new A(); B b = new B(); a.b=b; b.a=a; } }

In practice, however, the JVM uses an algorithm called Mark-Sweep, and the idea behind mark-Sweep garbage collection is simple: every object that a program cannot reach is garbage and can be collected.

Mark-purge collection has several stages as follows

Stage 1: Marking

The garbage collector marks all objects it arrives at, starting with the root reference. If we use the analogy of a teacher judging a test paper for a student, this is equivalent to the process of judging whether all the answers on the test paper are correct or wrong.

Phase 2: Cleaning

In the first phase all recyclable content can be recycled by the garbage collector. If an object is determined to be recyclable, the object is placed in a finalization queue and later executed by a low-priority finalizer thread automatically created by the virtual machine.

Stage 3: Finishing (optional)

Some collectors have a third step, sorting. In this step, GC moves the object into the free space left by the garbage collector. This prevents fragmentation of the heap and prevents large objects from being allocated in the heap due to discontinuities in heap space.

So the above process involves a root node (GC Roots) to determine whether there are objects to be recycled. The basic idea of this algorithm is to use a series of GC Roots as a starting point, search down from these nodes, the path traveled by the search is called a reference chain (Reference Chain), when an object to GC Roots does not have any reference chain connection, then prove that this object is unavailable. Any object that can be accessed in the chain of references is a strongly referenced object, and the garbage collector does not reclaim strongly referenced objects.

So, back in the foo() method, the parameter bar and the local variable baz are strong references only when the method is executed. Once the methods have finished executing and they are out of scope, the objects they refer to are garbage collected.

Consider an example

LinkedList foo = new LinkedList(); foo.add(new Integer(111));

The variable foo is a strong reference to a LinkedList object. A LinkedList(JDK.18) is a linked list data structure in which each element points to its predecessor and each element has its successor.

When we call the add() method, we add a new list element that points to the Integer instance with value 111. This is a string of strong references, meaning that this instance of Integer does not qualify for garbage collection. Once the foo object is out of the scope of the program, LinkedList and its references can be collected.

protected void finalize() throws Throwable { //Clear object}

Provided there are no strong references.

Finalizers

C++ allows objects to define destructor methods: when an object is out of scope or explicitly deleted, destructors are called to clean up the resources used. For most objects, destructors free memory allocated using new or malloc functions. In Java, the garbage collector automatically cleans up objects and allocates memory for you, so you don't need an explicit destructor to do this. This is also a big difference between Java and C++.

However, memory is not the only resource that needs to be freed. Consider FileOutputStream: When you create an instance of this object, it assigns a file handle from the operating system. What happens to the file handle if you let a reference to the stream go beyond its scope before closing? In fact, each stream has a finalizer method, which is called by the JVM before the garbage collector collects it. For FileOutputStream, the finalizer method closes the stream, releases the file handle to the operating system, and then clears the buffer to ensure that the data can be written to disk.

Any object has a finalizer method, all you have to do is declare the finalize() method. as follows

protected void finalize() throws Throwable { //Clear object}

Although finalizers 'finalize() method is a good way to clean up, the negative impact of this method is so great that you should not rely on it for any garbage collection. Because the finalize method is expensive and uncertain, it is impossible to guarantee the invocation order of each object. Finalize Anything you can do, you can do it try-finally or otherwise, or even better.

Life cycle of an object

To sum up, you can summarize the life cycle of an object through the following process

The object is created and initialized, the object is used at runtime, and then out of scope, the object becomes unreachable and collected by the garbage collector. The areas marked in red indicate that the object is in the strongly reachable phase.

JDK 1.2 introduced the java.lang.ref package, which has four stages in the life cycle of objects: Strong reachable? (Strongly Reachable?)、Soft Reachable?, Weak Reachable?, Phantom Reachable?.

If we are talking only about objects eligible for garbage collection, there are only three: soft reachability, weak reachability, and phantom reachability.

Soft accessible: soft accessible? Can we only use soft quotes? A soft-reachable object is an object referenced by SoftReference and has no strong reference. Soft references are used to describe objects that are useful but not necessary. The garbage collector retains soft-referenced objects for as long as possible, but collects them before an OutOfMemoryError occurs. If there is not enough memory to allocate after collecting the soft reference object, OutOfMemoryError will be thrown directly.

Weakly reachable: Weakly reachable objects are objects referenced by WeakReference. The garbage collector can collect weakly referenced objects at any time and does not attempt to retain soft referenced objects.

Phantom reachability: Phantom reachability is the object referenced by Phantom Reference, phantom reachability is when there are no strong, soft, or weak references associated, and it has been finalized, only when phantom references point to this object.

In addition, there are two reachability criteria: strong reachability and unreachability.

Strong reachability: An object that has just been created, initialized, and in use is in a state of strong reachability.

unreachable: An object that is unreachable means that the object can be purged.

Below is a diagram of transitions between different reachability states

Determining reachability criteria is also part of the JVM garbage collector's consideration in deciding how to process objects.

All object reachability references are subclasses of java.lang.ref.Reference, which has a get() method that returns the referenced object. This method returns null if the referenced object has been cleaned up by a program or garbage collector. In other words, soft and weak references are all objects that can be retrieved except phantom references. Moreover, these objects can be artificially rescued and become strong references, for example, by assigning the keyword this to the object, as long as it is associated with any object in the reference chain.

ReferenceQueue

The Reference Queue, also known as ReferenceQueue, is located under the java.lang.ref package. Are we there? Create various references (soft, weak, phantom) and associate them with the response object. You can choose whether you want to associate a reference queue. The JVM enqueues references at specific times, and programs can determine whether referenced objects are recycled by GC by determining whether references have been added to the reference queue.

Reference

java.lang.ref.Reference is the parent of soft, weak, and phantom references. Because the Reference object and garbage collection implementation closely match, the class may not be directly subclassed.

At this point, I believe that we have a deeper understanding of "how to understand java garbage collector," may wish to actually operate it! Here is the website, more related content can enter the relevant channels for inquiry, pay attention to us, continue to learn!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.