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

This article will explain in detail what are the real interview questions about JVM, and the content of the article is of high quality, so the editor will share it with you for reference. I hope you will have a certain understanding of the relevant knowledge after reading this article.

JVM series of knowledge, very important, the interview is basically a must.

1. Do objects have to be allocated in the heap? Do you know anything about escape analysis techniques?

"do objects have to be allocated in the heap? "not necessarily, JVM passes escape analysis, and objects that cannot escape the method will be allocated on the stack.

"what is escape analysis? "

Escape analysis (Escape Analysis) is a cross-function global data flow analysis algorithm that can effectively reduce the synchronous load and memory heap allocation pressure in Java programs. Through escape analysis, the Java Hotspot compiler can analyze the scope of use of a reference to a new object and decide whether to assign the object to the heap.

❝escape analysis is a method to analyze the dynamic range of pointers, which is related to pointer analysis and shape analysis of compiler optimization principles. When a variable (or object) is allocated in a method, its pointer may be returned or referenced globally, thus being referenced by other methods or threads, a phenomenon called Escape of pointers (or references). Generally speaking, if an object's pointer is referenced by multiple methods or threads, then we say that the object's pointer has escaped. ❞

"an example of escape analysis."

/ * * @ author the little boy who picked up the snail * / public class EscapeAnalysisTest {public static Object object; / / StringBuilder may have been changed by other methods and escaped to the outside of the method. Public StringBuilder escape (String a, String b) {StringBuilder str = new StringBuilder (); str.append (a); str.append (b); return str;} / / No direct return to StringBuffer, no escape public String notEscape (String a, String b) {StringBuilder str = new StringBuilder (); str.append (a); str.append (b); return str.toString () } / / external thread visible object, escaping public void objectEscape () {object = new Object ();} / / only visible inside the method, not escaping public void objectNotEscape () {Object object = new Object ();}}

"the benefits of escape analysis"

Allocation on the ❝stack reduces the frequency at which the garbage collector runs. Synchronization is eliminated, and if an object is found to be accessible from only one thread, operations on that object do not require synchronization. Scalar substitution breaks down objects into basic types, and memory allocation is no longer allocated on the heap, but on the stack. The benefits are as follows: first, reduce memory usage, because there is no need to generate object headers. Second, the program memory recovery efficiency is high, and the GC frequency will be reduced. ❞

two。 Why did the virtual machine replace the permanent generation with metaspace?

"what is metaspace? What is the eternal generation? Why use metaspace instead of permanent generation? "Let's review the * *" method area "* * and take a look at the data memory diagram at run time of the virtual machine, as follows:

The ❝method area, like the heap, is a memory area shared by each thread, which is used to store class information, constants, static variables, immediately compiled code and other data that have been loaded by the virtual machine. ❞

"what is the eternal generation? What does it have to do with the method area? "

If ❝is developed and deployed on a HotSpot virtual machine, many programmers refer to the method zone as permanent. It can be said that the method area is the specification, and the permanent generation is the implementation of the specification by Hotspot. In Java7 and previous versions, the method zone is implemented permanently. ❞

"what is metaspace? What does it have to do with the method area? "

❝cancels the permanent generation for Java8,HotSpots and replaces it with Metaspace. In other words, the method area is still there, but the implementation has changed from permanent generation to metaspace. ❞

"Why did you replace the permanent generation with metaspace? "

The method area of the permanent generation and the physical memory used by the heap are contiguous.

* * permanent generation * * is configured by the following two parameters ~

-XX:PremSize: sets the initial size of the permanent generation

-XX:MaxPermSize: sets the maximum value of the permanent generation. The default is 64m.

For * * "permanent generation", if you generate a lot of class dynamically, you are likely to have a "java.lang.OutOfMemoryError: PermGen space error" * *, because the configuration of permanent generation space is limited. The most typical scenario is when web develops more jsp pages.

After JDK8, the method area exists in the metaspace (Metaspace). Physical memory is no longer continuous with the heap, but exists directly in local memory. In theory, the machine * * has as much meta-space as it has memory.

You can set the size of the metaspace with the following parameters:

❝- XX:MetaspaceSize, the initial space size, which triggers garbage collection for type unloading, and GC adjusts the value: if a large amount of space is freed, the value is lowered appropriately; if very little space is freed, the value is increased appropriately when the MaxMetaspaceSize is not exceeded. -XX:MaxMetaspaceSize, the maximum space, there is no limit by default. -XX:MinMetaspaceFreeRatio, after GC, the minimum percentage of Metaspace remaining space capacity, reduced garbage collection caused by space allocation-XX:MaxMetaspaceFreeRatio, after GC, the maximum percentage of Metaspace remaining space capacity, reduced garbage collection ❞caused by free space

"so why use metaspace instead of permanent generation? "

❝is ostensibly designed to avoid OOM exceptions. Because you usually use PermSize and MaxPermSize to set the size of the permanent generation to determine the upper limit of the permanent generation, but you don't always know how appropriate it should be, and it's easy to encounter OOM errors if you use the default value. When using metaspace, the number of classes of metadata that can be loaded is no longer controlled by MaxPermSize, but by the actual available space of the system. ❞

3. What is Stop The World? What is OopMap? What is a safe place?

The movement of objects is involved in the process of garbage collection. In order to ensure the correctness of object reference updates, all user threads must be paused. Pauses like this are described by the virtual machine designer as * * "Stop The World" * *.

In HotSpot, there is a data structure (mapping table) called * * "OopMap". Once the class loading action is complete, HotSpot calculates what type of data on what offset in the object and records it to OopMap. During just-in-time compilation, an OopMap is also generated at a "specific location" * * to record which locations on the stack and in the register are references.

These specific locations are mainly:

1. The end of the loop (non-counted loop)

two。 The method returns immediately before / after the call instruction of the calling method

3. Where an exception may be thrown

These locations are called safepoint. "* * when a user program executes, it is not possible to start garbage collection at a pause anywhere in the code instruction stream, but it must be executed to a safe point before it can be paused.

4. What are the main components and functions of JVM?

JVM consists of two subsystems and two components, namely

❝Class loader (classloading subsystem) Execution engine (execution engine subsystem); Runtime data area (runtime datazone component) Native Interface (local interface component). ❞

"Class loader (class loading):" loads the class file into the method area of the runtime data area based on a given fully qualified class name, such as java.lang.Object.

Execution engine (execution engine): executes the instructions of the class.

"Native Interface (native interface):" interacting with native lib is the interface for other programming languages.

"Runtime data area (Runtime data region)": what we often call JVM memory.

❝first converts the Java source code into bytecode through the compiler, and then Class loader (class loading) loads the bytecode into memory and puts it in the method area of the runtime data area. The bytecode file is only a set of instruction set specifications of JVM and cannot be directly handed over to the underlying operating system for execution, so a specific command parser execution engine (Execution Engine) is needed to translate the bytecode into underlying system instructions. Then leave it to CPU to execute, and in this process, you need to call the native library interface (Native Interface) of other languages to realize the function of the whole program. ❞

5. What is a daemon thread? What is the difference between daemon and non-daemon threads? What is the role of the daemon thread?

The "daemon thread" is different from the user thread. The "user thread" is the thread we create manually, while the daemon thread is a thread that provides a "general service" in the background when the program is running. Garbage collection threads are typical daemon threads.

"what's the difference between daemon and non-daemon threads? "Let's look at it through examples.

/ * * / public static void main (String [] args) throws InterruptedException {Thread T1 = new Thread (()-> {while (true) {try {Thread.sleep (1000); System.out.println ("I am a child thread (user thread I am running") } catch (Exception e) {}); / / marked as daemon thread t1.setDaemon (true); / / start thread t1.start (); Thread.sleep (3000); System.out.println ("main thread finished executing...");}

Running result:

You can find that after being marked as a daemon thread, "the destruction of the main thread stops, and the daemon thread destroys together". Let's take a look at the effect of removing the t1.setDaemon (true) daemon:

Public static void main (String [] args) throws InterruptedException {Thread T1 = new Thread (()-> {while (true) {try {Thread.sleep (1000); System.out.println ("I am a child thread (user thread I am running") } catch (Exception e) {}); / / start thread t1.start (); Thread.sleep (3000); System.out.println ("main thread completed...");}

So, when the main thread exits, the JVM exits and the daemon thread is recycled, even if it is a dead loop. If it is a user thread, it will always stop running in an endless loop. This is the difference between daemon and non-daemon threads.

Daemon threads have the ability to end their lifecycles automatically, while non-daemon threads do not. If the garbage collection thread is a non-daemon thread, it is embarrassing that the program cannot exit because the garbage collection thread is still running when the JVM is about to exit. This is why the garbage collection thread needs to be a daemon thread.

Does 6.WeakHashMap know anything about it? How does it work?

"WeakHashMap" is similar to HashMap, except that the key of WeakHashMap is the key of * * "weak reference" * *.

When it comes to * * "weak references" * *, let's review the four citations here.

❝strong reference: Object obj=new Object (), the garbage collector will never recycle the referenced object as long as the strong reference relationship exists. Soft references: in general, weak references are not recycled until there is not enough memory to overflow: when the garbage collector starts to work, objects associated with weak references will be recycled regardless of whether the current memory is sufficient or not. Virtual reference: the only purpose of setting a virtual reference for an object is to receive a system notification when the object is reclaimed. ❞

Precisely because WeakHashMap uses weak references, "its objects can be recycled at any time." The behavior part of the WeakHashMap class * * "depends on the action of the garbage collector". Calling the size () method twice returns different values, calling isEmpty () twice, once returning true, and once returning false is "possible" * *.

WeakHashMap** "how it works" * * answers these two points:

❝WeakHashMap has the feature of weak citation: objects are recycled at any time. How does WeakHashMap remove Entry when GC occurs? ❞

Entry within WeakHashMap inherits WeakReference, that is, weak references, so it has the characteristics of weak references and can be "recycled at any time". Take a look at the source code:

Private static class Entry extends WeakReference implements Map.Entry {V value; final int hash; Entry next; / * Creates new entry. * / Entry (Object key, V value, ReferenceQueue queue, int hash, Entry next) {super (key, queue); this.value = value; this.hash = hash; this.next = next;}.

"how did WeakHashMap remove Entry? "after GC cleans up an object each time, the reference object is placed in ReferenceQueue, and then traverses the queue to delete it. The operation of adding, deleting, modifying and searching WeakHashMap is to directly / indirectly call the expungeStaleEntries () method to achieve the purpose of removing expired entry in time. You can take a look at the expungeStaleEntries source code:

/ * Expunges stale entries from the table. * / private void expungeStaleEntries () {for (Object x; (x = queue.poll ())! = null;) {synchronized (queue) {@ SuppressWarnings ("unchecked") Entry e = (Entry) x; int i = indexFor (e.hash, table.length); Entry prev = table [I] Entry p = prev; while (p! = null) {Entry next = p.next; if (p = = e) {if (prev = = e) table [I] = next Else prev.next = next; / / Must not null out e.next; / / stale entries may be in use by a HashIterator e.value = null; / / Help GC size--; break } prev = p; p = next;}} 7. Do you know Java grammar sugar? What are the 12 kinds of grammatical sugars commonly used in Java?

Grammatical Syntactic Sugar, also known as sugar-coated grammar, makes programs more concise and more readable. The most commonly used grammatical sugars in Java are generics, variable length parameters, conditional compilation, automatic unpacking, inner classes and so on.

Syntax Sugar one and switch support String and enumeration

Grammatical sugar II, generics

Grammar Sugar III. Automatic packing and unpacking

Grammar Sugar IV. Method variable length parameters

Grammar Sugar V. Enumeration

Grammar Sugar VI. Internal classes

Grammar Sugar VII. Conditional compilation

Grammar Sugar VIII. Assertion

Grammar Sugar Nine, numerical literal

Grammar Sugar X, for-each

Grammar Sugar 11, try-with-resource

Syntax Sugar XII, Lambda expression

Interested friends, can read this article ha: do not understand these 12 grammar sugars, do not say you can Java!

8. What is a pointer collision? What is a free list? What is TLAB?

❝in general, JVM objects are placed in heap memory (except for escape analysis). When the class load check passes, the Java virtual machine begins to allocate memory for the new object. If the memory in the Java heap is absolutely regular, all the used memory is put aside, and the free memory is put on the other side, with a pointer in the middle as an indicator of the demarcation point, and the allocated memory is only to move that pointer to the free space by moving an instance equal to the size of the object, this allocation is called "pointer collision". ❞

❝if the memory in the Java heap is not regular, the memory that has been used and the free memory are intertwined, and pointer collisions cannot be carried out, the virtual machine must maintain a list to record which memory is available, find a large piece of space from the list to allocate to the object instance, and update the records on the list, this allocation method is "free list" ❞.

Object creation is a very frequent behavior in virtual machines, and there may be linear security issues. If a thread is allocating memory to object A, and the pointer has not yet come and modified, while another thread allocating memory to object B still refers to the previous pointer, there will be a problem.

❝can divide the memory allocation into different spaces according to threads, and each thread pre-allocates a small piece of memory in the Java heap, which is * * "TLAB (Thread Local Allocation Buffer)". The virtual machine sets it through-XX:UseTLAB. ❞

The working process of the 9.CMS garbage collector, the difference between the CMS collector and the G1 collector.

CMS (Concurrent Mark Sweep) collector: a collector that aims to obtain the shortest recovery pause time, marks the removal algorithm, operates the process: "initial marking, concurrent marking, re-marking, concurrent clearing", and a large number of space debris will be generated at the end of the collection. As shown in the figure (the following figure comes from the Internet):

"difference between the CMS collector and the G1 collector:"

The CMS collector is an old collector that can be used with the new generation of Serial and ParNew collectors

The collection scope of G1 collector is old age and new generation, and does not need to be used in combination with other collectors.

CMS collector A collector aimed at minimizing pause time.

G1 collector can predict the pause time of garbage collection

The CMS collector is a garbage collection using the "mark-clear" algorithm, which is prone to memory fragmentation.

The G1 collector uses the mark-demarcation algorithm to integrate the space and reduce the memory space fragmentation.

10.JVM tuning

JVM tuning is really about tuning the JVM parameters, that is, tuning the garbage collector and memory allocation to achieve higher throughput and performance. JVM tuning mainly adjusts the following parameters

"stack memory related"

❝- Xms sets the initial heap size-Xmx sets the maximum heap size-Xmn sets the younger generation size This is equivalent to configuring-XX:NewSize and-XX:MaxNewSize to the same value at the same time-stack size for each thread of Xss-XX:NewSize sets the size of the younger generation (for 1.3)-XX:MaxNewSize maximum of the younger generation (for 1.3)-ratio of XX:NewRatio young to older (excluding persistent generations)-ratio of XX:SurvivorRatio Eden to Survivor-XX:PretenureSizeThreshold when the object created exceeds the specified size Assign the object directly to the old age. -XX:MaxTenuringThreshold sets the maximum age threshold for object replication in Survivor, beyond which it is transferred to the old ❞.

"garbage collector related"

❝- XX:+UseParallelGC: select the garbage collector as the parallel collector. -XX:ParallelGCThreads=20: configure the number of threads in the parallel collector-XX:+UseConcMarkSweepGC: set the older generation to collect concurrently. -XX:CMSFullGCsBeforeCompaction=5 because the concurrent collector does not compress or clean up the memory space, so it will produce "fragments" after running for a period of time, which reduces the running efficiency. This value sets the memory space to be compressed and organized after running GC for 5 times. -XX:+UseCMSCompactAtFullCollection: turn on the compression of the older generation. May affect performance, but can eliminate fragmented ❞

"Auxiliary information related"

❝- XX:+PrintGCDetails prints GC details-XX:+ HeapDumpOnOutOfMemoryError allows JVM to automatically generate memory snapshots in the event of a memory overflow, troubleshooting problems disable system System.gc () with-XX:+DisableExplicitGC to prevent problems caused by manual mistriggers of FGC.-XX:+PrintTLAB to view the usage of TLAB space ❞

What are the real interview questions about JVM to share here, I hope that the above content can be of some help to you, can learn more knowledge. If you think the article is good, you can share it for more people to see.

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.