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

This article mainly explains "what are the real questions of JVM interview". Friends who are interested might as well take a look. The method introduced in this paper is simple, fast and practical. Let's let the editor take you to learn what are the real questions in the JVM interview.

Question 1: JVM memory related (Baidu)

Q: do you understand the JVM memory model? put it simply.

A:

Because this piece of content is too much, many friends may not remember so much, so the following answers are divided into short answers and precise answers.

JVM runtime memory is divided into five parts: program counter, Java virtual machine stack, local method stack, heap and method area.

The biggest difference between jdk 1.8and jdk 1.7is that the metadata area replaces the permanent generation. The essence of meta-space is similar to that of permanent generation, which is the realization of the legal area in the JVM specification. However, the biggest difference between metaspace and permanent generation is that the metadata space is not in the virtual machine, but uses local memory.

Question 2: class loading related (Sina Weibo)

Q: what are the main procedures for jvm to load classes and how to load them?

A:

Short answer: the class loading process refers to the process that the JVM virtual machine loads the class information in the .class file into memory and parses it to generate the corresponding class object. It is divided into five steps: load-> verify-> prepare-> parse-> initialize. Load: load the external .class file into the Java virtual machine; verify: make sure that the amount information contained in the loaded calss file meets the requirements of the Java virtual machine; prepare: allocate memory for the class variable and set the initial value of the class variable; parse: change the symbol reference in the constant pool to direct reference; initialize the class variable and static code block.

Answer: early warning ahead, the content is long, be ready!

From the completion of coding to the final execution of a Java file, there are generally two main processes: compilation and running.

Compile: that is, we write the java file, through the javac command compiled into bytecode, that is, we often say. Class file.

Run: the compiled .class file is handed over to the Java virtual machine (JVM) for execution.

The class loading process we call refers to the process that the JVM virtual machine loads the class information in the .class file into memory and parses it to generate the corresponding class object.

Class loading process

For a simple example, JVM encounters class A while executing a certain piece of code, but there is no information about class An in memory, so JVM will go to the corresponding class file to find the class information of class An and load it into memory. This is what we call class loading process.

Thus, instead of loading all classes into memory at the beginning, JVM loads only once when it encounters a class that needs to be run for the first time.

Class loading

The process of class loading is mainly divided into three parts: loading, linking, and initialization.

The link can be subdivided into three small parts: validation, preparation, and parsing.

Load

Simply put, loading refers to loading class bytecode files from various sources into memory through a class loader.

Here are two key points:

Bytecode sources: general loading sources include .class files compiled from local paths, .class files from jar packages, real-time compilation from remote networks, and dynamic agents.

Class loader: generally includes startup class loader, extended class loader, application class loader, and user's custom class loader.

Note: why is there a custom class loader?

On the one hand, because the java code is easily decompiled, if you need to encrypt your own code, you can encrypt the compiled code, and then decrypt it by implementing your own custom class loader, and finally load it.

On the other hand, it is possible to load code from a non-standard source, such as a network source, then you need to implement a class loader that loads from the specified source.

Verification

The main purpose is to ensure that the loaded byte stream conforms to the virtual machine specification and will not cause security errors.

Including validation of file formats, such as whether there are unsupported constants in constants? Is there any non-standard or additional information in the file?

Validation of metadata, such as whether the class inherits a class modified by final? Does the method conflict with the parent class for the fields in the class? Is there an unreasonable overload?

The verification of bytecode ensures the rationality of program semantics, such as the rationality of type conversion.

For the verification of symbol references, such as verifying whether the corresponding class can be found through fully qualified names in symbol references? Is the accessibility (private,public, etc.) in the check symbol reference accessible to the current class?

Prepare for

The main thing is to allocate memory for class variables (note, not instance variables) and assign initial values.

In particular, it is important to note that the initial value is not the initialization value specifically written in the code, but the default initial value of the Java virtual machine according to different variable types.

For example, the initial value of 8 basic types is 0 by default; the initial value of reference type is null; constant, that is, the value set in the code, final

Static tmp = 456, then the initial value of tmp for this stage is 456.

Analysis

The process of replacing symbolic references within a constant pool with direct references.

Two key points:

Symbolic reference: a string, but this string gives some information that uniquely identifies a method, a variable, or a class.

Direct reference: can be understood as a memory address, or an offset. For example, for a class method, the direct reference to the class variable is the pointer to the method area, while the direct reference to the instance variable is the offset from the header pointer of the instance to the position of the instance variable.

For example, now call the method hello (), and the address of this method is 1234567, then hello is the symbolic reference and 1234567 is the direct reference.

In the parsing phase, the virtual machine replaces all symbolic references such as class names, method names, and field names with specific memory addresses or offsets, that is, direct references.

Initialization

This phase is mainly about initializing class variables and the process of executing the class constructor.

In other words, only variables or statements modified by static are initialized.

If when a class is initialized, its parent class has not been initialized, its parent class is initialized first.

If multiple static variables and static code blocks are included at the same time, they are executed in top-down order.

Summary

The class loading process is only part of a class life cycle. Before it, there is a compilation process. Only after compiling the source code can we get bytecode files that can be loaded by the virtual machine. After that, there is a specific class use process. When the use is complete, it will also be unloaded in the method area garbage collection process. If you want to understand the entire life cycle of the Java class, you can check the relevant information on the Internet on your own. I won't repeat it here.

Question 3: JVM memory related (Yuncong Technology)

Q: is there a memory leak in Java? please describe it briefly.

A:

In theory, Java will not have memory leaks because of its garbage collection mechanism (GC) (this is also an important reason why Java is widely used in server-side programming); however, in practical development, there may be useless but reachable objects that cannot be reclaimed by GC and memory leaks will occur.

One example is that objects in Hibernate's Session (first-level cache) are persistent, and the garbage collector does not recycle these objects, but there may be useless garbage objects in these objects.

The following example also shows a memory leak in Java:

Package com.yuan_more;import java.util.Arrays;import java.util.EmptyStackException;public class MyStack {private T [] elements; private int size = 0; private static final int INIT_CAPACITY = 16; public MyStack () {elements = (T []) new object [INIT _ CAPACITY];} public void push (T elem) {ensureCapacity () } public T pop () {if (size = = 0) {throw new EmptyStackException ();} return elements [--size];} private void ensureCapacity () {if (elements.length = = size) {elements = Arrays.copyOf (elements,2 * size + 1);}

The above code implements a stack (FILO) structure, which at first glance seems to have no obvious problem, and it can even pass the various unit tests you write.

However, the pop method has the problem of memory leak, when we use the pop method to pop up the objects in the stack, the object will not be regarded as garbage collection, even if the program that uses the stack no longer references these objects, because the obsolete reference of these objects is maintained inside the stack.

In languages that support garbage collection, memory leaks are hidden, and such memory leaks are actually unconscious object persistence.

If an object reference is unconsciously retained, then the garbage collector will not process the object or other objects referenced by the object. Even if there are only a few such objects, it may cause many objects to be excluded from garbage collection, which will have a significant impact on performance. In extreme cases, it will trigger Disk Paging (physical memory exchanges data with the virtual memory of the hard disk) And even cause OutOfMemoryError.

Question 4: garbage collection related (DiDi)

Q: do you know GC? Why is there a GC?

A:

GC means garbage collection. Memory processing is a place where programmers are prone to problems. Forgetting or incorrect memory collection will lead to instability or even crash of the program or system.

The GC function provided by Java can automatically monitor whether the object exceeds the scope so as to achieve the purpose of automatic memory recovery. Java language does not provide a display operation method to release allocated memory. Java programmers don't have to worry about memory management because the garbage collector manages it automatically.

To request garbage collection, you can call one of the following methods: System.gc () or Runtime.getRuntime (). Gc (), note that it is only a request, and it is unpredictable when JVM will perform garbage collection.

Garbage collection can effectively prevent memory leakage and effectively use the available memory. The garbage collector usually runs as a separate low-priority thread to unpredictably clear and collect dead or unused objects in the memory heap. Programmers cannot call the garbage collector to garbage collect an object or all objects in real time.

In the early days of Java, garbage collection is one of the biggest bright spots of Java, because server-side programming needs to effectively prevent memory leaks, but times have changed, and now Java's garbage collection mechanism has become criticized. Mobile intelligent end-users usually think that iOS system has a better user experience than Android system. One of the deep-seated reasons is the unpredictability of garbage collection in Android system.

Question 5: JVM memory related (Ali)

Q: why do heaps in Hotspot virtual machines have new and old generations?

A:

Because some objects have a long life and some objects have a short life. Long-lived objects should be placed in one area, and short-lived objects should be placed in one area. Different districts use different garbage collection algorithms. The cleaning frequency of the area with short life is higher, and the cleaning frequency of the area with long life is lower, which improves the efficiency.

The so-called new generation and the old age are defined according to the generation collection algorithm, and the new generation is divided into two areas: Eden and Survivor. Plus the only three districts in the old days.

Data is first allocated to the Eden area, and there are special cases where large objects are put directly into the old age (large objects are java objects that require a lot of contiguous memory space). When Eden does not have enough space, it triggers jvm to initiate a Minor GC. The new generation of garbage collection uses replication algorithm.

If the object survives after a Minor GC and is accepted by the Survivor space, it will be moved to the Survivor space. And set its age to 1, each time the object gets through the Minor GC in Survivor, the age will be increased by 1. When the age reaches a certain level (the default is 15), it will be promoted to the old age, of course, the age of promotion can be set. If the old age is over, execute: Full GC, because it is not often executed, so the old garbage collection uses the tag-collation (Mark-Compact) algorithm.

At this point, I believe you have a deeper understanding of "what are the real questions of the JVM interview?" you might as well do it in practice. Here is the website, more related content can enter the relevant channels to inquire, follow 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.