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

This article mainly explains "how to understand the escape in Java". The content in the article is simple and clear, and it is easy to learn and understand. Please follow the editor's train of thought to study and learn "how to understand escape in Java".

In the Java compilation system, when a Java source code file becomes a computer-executable machine instruction, it needs to go through two stages of compilation. the first is to convert a .java file into a .class file. The second stage of compilation is the process of converting .class into machine instructions.

The first compilation is the javac command.

In the second compilation phase, JVM interprets the bytecode into corresponding machine instructions, reads it in one by one, and interprets the translation one by one. Obviously, after interpretation, the execution speed is bound to be much slower than the executable binary bytecode program. This is what the traditional JVM interpreter (Interpreter) does. In order to solve this efficiency problem, JIT (just-in-time compilation) technology is introduced.

After the introduction of JIT technology, Java programs are still interpreted and executed through an interpreter, and when JVM finds that a method or block of code runs very frequently, it will consider it a "Hot Spot Code". JIT then translates some of the "hot code" into local machine-related machine code, optimizes it, and then caches the translated machine code for next use.

Because of the content about JIT compilation and hot spot detection, I have already introduced it in the in-depth analysis of the compilation principle of Java, so I will not repeat it here. This article mainly introduces the optimization in JIT. One of the most important aspects of JIT optimization is escape analysis.

Escape analysis

With regard to the concept of escape analysis, you can refer to that objects and arrays do not allocate memory on the heap. Here is a brief review of this article:

The basic behavior of escape analysis is to analyze the dynamic scope of an object: when an object is defined in a method, it may be referenced by an external method, such as passing it to other places as a calling parameter, called method escape.

For example, the following code:

Public static StringBuffer craeteStringBuffer (String S1, String S2) {

StringBuffer sb = new StringBuffer ()

Sb.append (S1)

Sb.append (S2)

Return sb

}

Public static String createStringBuffer (String S1, String S2) {

StringBuffer sb = new StringBuffer ()

Sb.append (S1)

Sb.append (S2)

Return sb.toString ()

}

The sb in the first code escaped, while the sb in the second code did not escape.

Using escape analysis, the compiler can optimize the code as follows:

First, synchronous ellipsis. If an object is found to be accessible only from one thread, synchronization may not be considered for the operation of that object.

Second, convert heap allocation to stack allocation. If an object is allocated in a subroutine, the object may be a candidate for stack allocation rather than heap allocation so that the pointer to the object never escapes.

Third, separate objects or scalar substitution. Some objects may not need to exist as a contiguous memory structure to be accessed, so some (or all) of the objects can be stored not in memory, but in CPU registers.

When the Java code is running, you can specify whether to turn on escape analysis through the JVM parameter

-XX:+DoEscapeAnalysis: enable escape analysis

-XX:-DoEscapeAnalysis: indicates that escape analysis has been disabled by default since jdk 1.7.If you want to disable it, you need to specify-XX:-DoEscapeAnalysis.

Synchronous ellipsis

When compiling synchronous blocks dynamically, the JIT compiler can use escape analysis to determine whether the lock objects used by synchronous blocks can only be accessed by one thread but not published to other threads.

If the lock object used by the synchronization block is proved to be accessible by only one thread through this analysis, then the JIT compiler will unsynchronize this part of the code when compiling the synchronization block. This process of de-synchronization is called synchronization ellipsis, also known as lock elimination.

Such as the following code:

Public void f () {

Object hollis = new Object ()

Synchronized (hollis) {

System.out.println (hollis)

}

}

The hollis object is locked in the code, but the life cycle of the hollis object is only in the f () method and is not accessed by other threads, so it is optimized during the JIT compilation phase. Optimized to:

Public void f () {

Object hollis = new Object ()

System.out.println (hollis)

}

Therefore, when using synchronized, lock elimination will be done if JIT does not have a thread safety problem after escape analysis.

Scalar substitution

Scalar refers to a piece of data that can no longer be decomposed into smaller data. The raw data type in Java is scalar. In contrast, the data that can also be decomposed is called Aggregate, and the object in Java is the aggregate quantity, because it can be decomposed into other aggregate quantities and scalars.

In the JIT phase, if after escape analysis, it is found that an object will not be accessed by the outside world, then after JIT optimization, the object will be disassembled into several member variables contained in it. This process is scalar substitution.

Public static void main (String [] args) {

Alloc ()

}

Private static void alloc () {

Point point = new Point (1mai 2)

System.out.println ("point.x=" + point.x+ "; point.y=" + point.y)

}

Class Point {

Private int x

Private int y

}

In the above code, the point object does not escape the alloc method, and the point object can be disassembled into scalars. Instead of creating a Point object, JIT directly replaces the Point object with two scalar int x and int y.

The above code, after scalar replacement, becomes:

Private static void alloc () {

Int x = 1

Int y = 2

System.out.println ("point.x=" + x + "; point.y=" + y)

}

It can be seen that the aggregate amount of Point was replaced by two polymerization quantities after escape analysis, which found that he did not escape. So what are the benefits of scalar substitution? It can greatly reduce the footprint of heap memory. Because once you don't need to create an object, you no longer need to allocate heap memory.

Scalar substitution provides a good basis for allocation on the stack.

Stack allocation

In the Java virtual machine, it is common sense that objects allocate memory in the Java heap. However, there is a special case, that is, if after escape analysis, it is found that an object has no escape method, then it may be optimized to be allocated on the stack. This eliminates the need to allocate memory on the heap and does not require garbage collection.

For a detailed description of allocation on the stack, you can refer to that objects and arrays do not allocate memory on the heap.

Here, let's briefly say that in existing virtual machines, there is no real allocation on the implementation stack, and not all objects and arrays allocate memory on the heap. In our example, objects are not allocated on the heap, but are actually implemented by scalar substitution.

Escape analysis is immature.

The paper on escape analysis was published in 1999, but it was not implemented until JDK 1.6, and the technology is not very mature so far.

The fundamental reason is that there is no guarantee that the performance consumption of escape analysis will be higher than his consumption. Although after escape analysis, scalar substitution, stack allocation, and lock elimination can be done. However, escape analysis itself also needs a series of complex analysis, which is actually a relatively time-consuming process.

An extreme example is that after escape analysis, it is found that no object does not escape. Then the process of escape analysis will be wasted.

Although this technology is not very mature, it is also a very important means of just-in-time compiler optimization.

Thank you for your reading, the above is the content of "how to understand the escape in Java". After the study of this article, I believe you have a deeper understanding of how to understand the escape in Java, and the specific use needs to be verified in practice. Here is, the editor will push for you more related knowledge points of the article, welcome to follow!

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.