Java Java Garbage Collection mechanism

Java garbage collection mechanism

When it comes to garbage collection (garbage collection,gc), many people naturally connect it to Java. In Java, programmers don't have to worry about memory dynamic allocations and garbage collection issues, all of which are given to the JVM to handle. Garbage collection, as the name implies, frees up space for garbage, so what objects in Java are considered "junk"? What strategies are used to reclaim (free space) after some objects have been identified as garbage? What are the typical garbage collectors in today's commercial virtual machines? Let's take a discussion of these issues. The following is the directory outline for this article:

I. How to determine if an object is "junk"?

Two. Typical garbage collection algorithms

Three. Typical garbage collector

If there are any mistakes, I would appreciate your understanding and criticism.

Please respect the author's labor results, reproduced please indicate the original link:

Http://www.cnblogs.com/dolphin0520/p/3783345.html

I. How to determine if an object is "junk"?

In this section we first understand one of the most basic questions: What if it is determined that an object is "junk"? Since the garbage collector's task is to reclaim the space occupied by garbage objects for use by new objects, how does the garbage collector determine that an object is "junk"? -that is, by what means an object can be recycled.

In Java, it is associated with an object by reference, that is, if you want to manipulate the object, you must do so by reference. So, obviously, a simple way is to determine whether an object can be recycled by reference counting. Without losing its generality, if an object does not have any references associated with it, then the object is basically unlikely to be used elsewhere, and the object becomes a recyclable object. This approach becomes the reference counting method.

This approach is characterized by simplicity and high efficiency, but it does not solve the problem of circular references, so this is not the case in Java (Python uses the reference notation). Look at the following code:

12345678910111213141516

publicclassMain {    publicstaticvoidmain(String[] args) {        MyObject object1 = newMyObject();        MyObject object2 = newMyObject();                object1.object = object2;        object2.object = object1;                object1 = null;        object2 = null;    }}classMyObject{    publicObject object = null;}

The last two sentences assign Object1 and object2 null, which means that object1 and object2 are no longer accessible, but because they reference each other and cause their reference count to be 0, the garbage collector never recycles them.

In order to solve this problem, the accessibility analysis method was adopted in Java. The basic idea of this method is to search by a series of "GC Roots" objects as a starting point, if there is no unreachable path between "GC Roots" and an object, it is said that the object is unreachable, but it is important to note that objects that are judged to be unreachable do not necessarily become recyclable objects. An object that is judged unreachable must undergo at least two marking processes to become a recoverable object, and if it is still not possible to escape from being a recyclable object during these two marks, it is essentially a recyclable object.

As to how the accessibility analysis method is specific, I do not see very clearly, if any friend is more clear, please feel free.

Let's look at an example:

1234567

Object aobj = newObject ( ) ; Object bobj = new Object ( ) ; Object cobj = newObject ( ) ; aobj = bobj; aobj = cobj; cobj = null; aobj = null;

The first few lines are likely to make an object a recyclable object? The code in line 7th causes the object to become recyclable. As for why leave the reader to think for themselves.

Let's look at an example:

123	string str = new   string ( "Hello" softreference<string> sr = new  softreference<string> ( new  string ( "Java" weakreference<string> WR = new  weakreference<string> ( new  string ( "world"

Which of these three sentences makes a string object a recyclable object? The 2nd sentence and the 3rd sentence, the 2nd sentence the string object will be judged as a recyclable object in the case of insufficient memory, and the 3rd clause can be judged as a recyclable object under any circumstances.

At the end of the day, we summarize the more common cases in which objects are judged to be recyclable:

1) Assign a reference to null or point a reference to an object to a new object, such as the following code:

12345

Object obj = newObject();obj = null;Object obj1 = new Object();Object obj2 = newObject();obj1 = obj2;

2) The object that the local reference refers to, such as the following code:

12345678

void  fun () {   ... &NBSP;&NBSP;&NBSP;&NBSP; for ( int  i= 0 ;I< 10 ;i++) { &NBSP;&NBSP;&NBSP;&NBSP;&NBSP;&NBSP;&NBSP;&NBSP; object obj = new  object (); &NBSP;&NBSP;&NBSP;&NBSP;&NBSP;&NBSP;&NBSP;&NBSP; system.out.println (Obj.getclass ()); &NBSP;&NBSP;&NBSP;&NBSP; }    }

Each time the loop finishes executing, the resulting object object becomes a recyclable object.

3) Only weak references to objects associated with them, such as:

1	WeakReference<String> wr = newWeakReference<String>(newString("world"));

Two. Typical garbage collection algorithms

After determining which garbage can be recycled, what the garbage collector has to do is start a garbage collection, but there is one problem: how to effectively recycle. Because the Java Virtual Machine specification does not explicitly stipulate how to implement a garbage collector, each vendor's virtual machine can implement a garbage collector in different ways, so it is only a discussion of the core ideas of several common garbage collection algorithms.

1.mark-sweep (Mark-Clear) algorithm

This is the most basic garbage collection algorithm, the reason is that it is the most basic because it is the easiest to achieve, the idea is the simplest. The tag-purge algorithm is divided into two stages: the tagging phase and the purge phase. The task of the tagging phase is to mark out all objects that need to be recycled, and the purge phase is to reclaim the space occupied by the tagged objects. The exact process is as follows:

It is easy to see that the tag-purge algorithm is easier to implement, but one of the more serious problems is that it is prone to memory fragmentation, and too many fragments can cause the subsequent process to allocate space for large objects without finding enough space to trigger a new garbage collection action ahead of time.

2.Copying (copy) algorithm

In order to solve the defect of mark-sweep algorithm, the copying algorithm is proposed. It divides the available memory by capacity into two blocks of equal size, using only one piece at a time. When this piece of memory is used up, copy the surviving object to another piece, and then clean up the used memory space once, so the memory fragmentation problem is not easy. The exact process is as follows:

This algorithm is simple, efficient, and not prone to memory fragmentation, but it has a high cost of using memory space because it can use less memory than half the original.

Obviously, the efficiency of the copying algorithm is very much related to the number of surviving objects, if there are many surviving objects, then the efficiency of the copying algorithm will be greatly reduced.

3.mark-compact (marker-collation) algorithm

In order to solve the defect of copying algorithm and make full use of memory space, the mark-compact algorithm is proposed. The algorithm marks the same stage as Mark-sweep, but after the token is completed, it does not clean the recyclable object directly, but instead moves the surviving object to one end and then cleans up memory outside the end boundary. The exact process is as follows:

　　

4.Generational Collection (generational collection) algorithm

The generational collection algorithm is the algorithm used by most of the JVM's garbage collectors today. Its core idea is to divide the memory into several different regions based on the life cycle of the object's survival. In general, the heap zoning is divided into the old age (tenured Generation) and the New Generation (young Generation), the characteristics of the old age is that each garbage collection only a small number of objects need to be recycled, and the new generation is characterized by a large number of objects to be recycled each time the garbage collected, Then we can take the most suitable collection algorithm according to the characteristics of different generations.

At present, most of the garbage collectors take the copying algorithm for the new generation, because each garbage collection in the Cenozoic has to reclaim most of the objects, that is, the number of operations that need to replicate is less, but the actual is not in accordance with the ratio of 1:1 to divide the new generation of space, In general, the Cenozoic is divided into a larger Eden space and two smaller survivor space, each time using Eden space and one of the survivor space, when recycling, Copy objects that are still alive in Eden and survivor to another survivor space, and then clean up Eden and the survivor space you just used.

Because of the characteristics of the old age is that each recycling only a small number of objects, the general use of the mark-compact algorithm.

Note that there is another generation outside the heap that is the permanent generation (permanet Generation), which is used to store class classes, constants, method descriptions, and so on. The recovery of the permanent generation mainly recycles two parts: obsolete constants and useless classes.

Three. Typical garbage collector

Garbage collection algorithm is the theoretical basis of memory recovery, and garbage collector is the concrete implementation of memory recovery. Here's a look at some of the garbage collectors available from the hotspot (JDK 7) virtual machine, which allows users to assemble the collectors used in each generation according to their needs.

1.serial/serial old

The serial/serial old collector is the most basic and oldest collector, which is a single-threaded collector and must suspend all user threads when it is garbage collected. Serial Collector is for the new generation of collectors, the use of the copying algorithm, Serial old collector is a collector for the older era, using the mark-compact algorithm. Its advantages are simple and efficient, but the disadvantage is that it will bring a pause to the user.

2.ParNew

The Parnew Collector is a multithreaded version of the serial collector that uses multiple threads for garbage collection.

3.Parallel Scavenge

The Parallel scavenge collector is a new generation of multi-threaded collectors (parallel collectors) that do not need to pause other user threads during recycling, using the copying algorithm, which differs from the first two collectors, primarily to achieve a manageable throughput.

4.Parallel old

Parallel old is the older version of the Parallel scavenge collector (parallel collector), using multithreading and Mark-compact algorithms.

5.CMS

The CMS (current Mark Sweep) collector is a collector that targets the shortest payback time and is a concurrent collector, using the mark-sweep algorithm.

6.g1

The G1 collector is the forefront of today's collector technology, a collector for service-side applications that leverages multi-CPU, multicore environments. So it is a parallel and concurrent collector, and it can build a predictable pause-time model.

Let's add something about memory allocation:

　　

The memory allocation of the object, which is allocated on the heap in the general direction, is mainly allocated to the new generation of Eden space and from space, and in rare cases it is directly allocated in the old age. If there is not enough space in the new generation of Eden space and from space, a GC is initiated, and if a GC is made, Eden space and from space can hold the object in Eden space and from space. During GC, the surviving objects in Eden Space and from space are moved to space, and then the Eden space and from space are cleaned. If the to space is not sufficient to store an object during the cleanup process, the object is moved to the old age. After the GC is performed, Eden Space and to space are used, and the next GC will replicate the surviving object to the from Space, so that it loops back and forth. When an object escapes a GC in the Survivor area, its object age increases by 1, and by default, if the object reaches 15 years old, it will move to the old age.

In general, large objects are allocated directly to the old age, so-called large objects are objects that require a large amount of contiguous storage space, and the most common large objects are large arrays, such as:

byte[] data = new byte[4*1024*1024]

This typically allocates storage space directly in the old age.

Of course, the rules for allocation are not completely fixed, depending on which garbage collector combination is currently being used and the parameters of the JVM.

Resources:

"In-depth understanding of Java virtual machines"