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

This article introduces the relevant knowledge of "what are the basic interview questions for JVM". In the operation of actual cases, many people will encounter such a dilemma. Next, let the editor lead you to learn how to deal with these situations. I hope you can read it carefully and be able to achieve something!

1 Overview

For Java programmers, under the automatic memory management mechanism of virtual machines, it is no longer necessary for programmers to write the corresponding delete/free operation for an inner new operation, such as Cmax Clipper + programmers, which is not prone to memory leaks and memory overflows. It is precisely because Java programmers hand over memory control to the Java virtual machine, once there are memory leaks and overflow problems, if you do not understand how the virtual machine uses memory, then troubleshooting errors will be a very difficult task.

2 Runtime data area

The Java virtual machine divides the memory it manages into several different data regions during the execution of the Java program.

Some of these components are private to threads, while others are shared by threads.

Thread private:

Program counter

Virtual machine stack

Local method stack

Thread shared:

Heap

Method area

Direct memory

2.1 Program counter

A program counter is a small piece of memory space that can be seen as a line number indicator of the bytecode executed by the current thread. When the bytecode interpreter works, it selects the next bytecode instruction to be executed by changing the value of this counter. Branch, loop, jump, exception handling, thread recovery and other functions all rely on this counter.

In addition, in order to restore to the correct execution position after thread switching, each thread needs to have an independent program counter, which does not affect each other and is stored independently. We call this kind of memory area "thread private" memory.

From the above introduction, we know that program counters have two main functions:

The bytecode interpreter reads instructions in turn by changing the program counter, thus realizing the flow control of the code, such as sequential execution, selection, loop and exception handling.

In the case of multithreading, the program counter is used to record the location of the current thread's execution, so that when the thread is switched back, it can know where the thread last ran.

Note: the program counter is the only area of memory that does not have OutOfMemoryError. Its life cycle is created as the thread is created and dies as the thread ends.

2.2 Java virtual machine stack

Like program counters, the Java virtual machine stack is thread-private, has the same life cycle as threads, and describes the memory model of Java method execution.

Java memory can be roughly divided into heap memory (Heap) and stack memory (Stack), in which stack is now called virtual machine stack, or local variable table part of virtual machine stack. (in fact, the Java virtual machine stack is made up of stack frames, and each stack frame has local variables, Operand stacks, dynamic links, and method exit information.)

The local variable table mainly stores various data types known to the compiler (boolean, byte, char, short, int, float, long, double) and object references (reference type, which is different from the object itself, it may be a reference pointer to the starting address of the object, or it may point to a handle representing the object or other locations related to the object).

There are two exceptions to the Java virtual machine stack: StackOverFlowError and OutOfMemoryError.

StackOverFlowError: if the memory size of the Java virtual machine stack does not allow dynamic expansion, a StackOverFlowError exception is thrown when the depth of the thread request stack exceeds the maximum depth of the current Java virtual machine stack.

OutOfMemoryError: if the memory size of the Java virtual machine stack allows dynamic expansion, and when the memory is used up when the thread requests the stack, it can no longer be dynamically expanded, then an OutOfMemoryError exception is thrown.

The Java virtual machine stack is also thread-private, and each thread has its own Java virtual machine stack, which is created as the thread is created and dies as the thread dies.

2.3 Local method stack

The role of the virtual machine stack is very similar to that of the virtual machine stack, except that the virtual machine stack performs Java methods (that is, bytecode) services for the virtual machines, while the local method stacks serve the Native methods used by the virtual machines. Merge with the Java virtual machine stack in the HotSpot virtual machine.

When a local method is executed, a stack frame is also created on the local method stack to store the local variable table, Operand stack, dynamic link, and exit information of the local method.

After the execution of the method, the corresponding stack frame will also be off the stack and free memory space, and there will also be two kinds of exceptions: StackOverFlowError and OutOfMemoryError.

2.4 heap

The largest piece of memory managed by the Java virtual machine, the Java heap is an area of memory shared by all threads and created when the virtual machine starts. The sole purpose of this memory area is to store object instances, where almost all object instances and arrays allocate memory.

Java heap is the main area managed by garbage collector, so it is also called GC heap (Garbage Collected Heap). From the perspective of garbage collection, since collectors basically use generation-by-generation garbage collection algorithms, Java heap can also be subdivided into: new generation and old age: more detailed: Eden space, From Survivor, To Survivor space and so on. The purpose of further partitioning is to better reclaim memory, or to allocate memory faster.

Remove the entire permanent generation in JDK 1.8 and replace it with an area called Metaspace (permanent generation uses JVM's heap memory space, while metaspace uses physical memory, which is directly limited by native physical memory).

Recommended reading: Java8 memory model-permanent generation (PermGen) and metaspace (Metaspace)

2.5 method area

Like the Java heap, the method area is a memory area shared by each thread, which is used to store class information, constants, static variables, compiled code and other data that have been loaded by the virtual machine. Although the Java virtual machine specification describes the method area as a logical part of the heap, it has an alias called Non-Heap (non-heap), which is supposed to distinguish it from the Java heap.

The method zone in the HotSpot virtual machine is also often referred to as "permanent generation", which is not equivalent in nature. Simply because the HotSpot virtual machine design team implements the method area with permanent generations, the garbage collector of the HotSpot virtual machine can manage this part of memory as if it were a Java heap. But this is not a good idea, because it is more likely to encounter memory overflow problems.

Relatively speaking, garbage collection behavior is relatively rare in this area, but it is not "permanent" after the data enters the method area.

2.6 run-time pool

The run-time pool is part of the method area. In addition to the version, field, method, interface and other description information of the class, there is also constant pool information (used to store various literals and symbol references generated during compilation) in the Class file.

Since part of the method area when running the constant pool, it is naturally limited by the memory in the method area, and an OutOfMemoryError exception is thrown when the constant pool can no longer apply for memory.

JDK1.7 and later versions of JVM have moved the runtime pool out of the method area, opening up an area to hold the runtime pool in the Java heap (Heap).

Recommended reading: the distinction of several constant pools in Java

2.7 Direct memory

Direct memory is not part of the runtime data area of the virtual machine, nor is it the memory area defined in the virtual machine specification, but this part of memory is also used frequently. It may also cause OutOfMemoryError exceptions to occur.

The newly added NIO (New Input/Output) class in JDK1.4 introduces a way based on channel (Channel) and cache (Buffer). It can directly allocate out-of-heap memory using the Native function library, and then operate through a DirectByteBuffer object stored in the Java heap as a reference to this memory. This can significantly improve performance in some scenarios because it avoids copying data back and forth between the Java heap and the Native heap.

The allocation of native direct memory is not limited by the Java heap, but since it is memory, it is limited by the total native memory size and processor addressing space.

3. Explore the object of HotSpot virtual machine

Through the above introduction, we have a general idea of the memory of the virtual machine. Let's take a detailed look at the whole process of object allocation, layout and access of the HotSpot virtual machine in the Java heap.

3.1 creation of objects

The following figure shows the process of creating a Java object, and I suggest that it is best to write it down and know what you are doing at each step.

Java object creation process

1. Class loading check: when the virtual machine encounters a new instruction, it will first check whether the parameters of the instruction can locate the symbolic reference of the class in the constant pool, and check whether the class represented by the symbolic reference has been loaded, parsed and initialized. If not, you must first perform the corresponding class loading process.

two。 Allocate memory: after the class load check passes, the virtual machine then allocates memory to the new object. The amount of memory required for an object can be determined after the class is loaded, and the task of allocating space for an object is tantamount to dividing a determined-sized piece of memory from the Java heap. There are two allocation methods: "pointer collision" and "free list". The choice of allocation method is determined by whether the Java heap is regular or not, and whether the Java heap is regular or not is determined by whether the garbage collector is equipped with compression and sorting function.

Two ways of memory allocation: (supplementary content, need to be mastered)

Which of the above two methods you choose depends on whether the Java heap memory is regular or not. Whether the Java heap memory is regular or not depends on whether the GC collector's algorithm is "mark-clear" or "mark-clean" (also known as "mark-compression"). It is worth noting that the memory of the replication algorithm is also regular.

Concurrency of memory allocation (supplementary content, need to be mastered)

There is a very important issue when creating objects, that is, thread safety, because in the actual development process, creating objects is very frequent. As a virtual machine, we must ensure that the thread is safe. Generally speaking, virtual machines use two ways to ensure thread safety:

CAS+ failed retry: CAS is an implementation of optimistic locking. The so-called optimistic lock is to complete an operation without locking each time on the assumption that there is no conflict, and if it fails because of the conflict, try again until it succeeds. The virtual machine uses CAS with failed retry to ensure the atomicity of the update operation.

TLAB: each thread is pre-allocated a block of memory in the Eden area. When JVM allocates memory to objects in a thread, it first allocates memory in TLAB, and then uses the above CAS to allocate memory when the object is larger than the remaining memory in TLAB or when the memory of TLAB has been exhausted.

3. Initialization zero: after the memory allocation is completed, the virtual machine needs to initialize the allocated memory space to zero (excluding object headers). This step ensures that the instance fields of the object can be used directly without initial values in the Java code, and the program can access the zero values corresponding to the data types of these fields.

4. Set object header: after initializing zero, the virtual machine sets the necessary object, such as the object is an instance of that class, how to find the metadata information of the class, the hash of the object, the GC generation age of the object, and so on. This information is stored in the object header. In addition, depending on the current running state of the virtual machine, such as whether to enable bias locks, the object header will be set in different ways.

5. Execute the init method: after all the above work is done, a new object has been generated from the perspective of the virtual machine, but from the perspective of the Java program, the object creation has just begun, the method has not been executed, and all fields are still zero. So generally speaking, the execution of the new instruction is followed by the execution of the method, initializing the object according to the wishes of the programmer, so that a truly available object is fully produced.

3.2 memory layout of objects

In the Hotspot virtual machine, the layout of objects in memory can be divided into three areas: object headers, instance data, and alignment padding.

The object header of the Hotspot virtual machine includes two parts of information, the first part is used to store the object's own runtime data (hash code, GC generation age, lock status flag, etc.), and the other part is the type pointer, that is, the object points to its class metadata. The virtual machine uses this pointer to determine which class the object is an instance of.

The instance data part is the valid information really stored by the object, and it is also the content of various types of fields defined in the program.

The alignment filling part does not necessarily exist, nor does it have any special meaning, but only plays a role in occupying space. Because the automatic memory management system of the Hotspot virtual machine requires that the starting address of the object must be an integral multiple of 8 bytes, in other words, the size of the object must be an integral multiple of 8 bytes. The header part of the object is exactly a multiple of 8 bytes (1 or 2 times), so when the object instance data part is not aligned, it needs to be filled by alignment padding.

3.3 access positioning of objects

Objects are created to use objects, and our Java program manipulates specific objects on the heap through reference data on the stack. The access method of object depends on the implementation of virtual machine. At present, the mainstream access methods are handle and direct pointer:

1. Handle: if a handle is used, a piece of memory will be allocated in the Java heap to serve as the handle pool. What is stored in reference is the handle address of the object, and the handle contains the specific address information of the object instance data and the type data.

Access objects through handles

two。 Direct pointer: if direct pointer access is used, then the layout of the Java heap object must consider how to place information about the access type data, and the address of the object is directly stored in reference.

Access objects through direct pointers

These two object access methods have their own advantages. The biggest advantage of using handles for access is that reference stores a stable handle address, which only changes the instance data pointer in the handle when the object is moved, while the reference itself does not need to be modified. The biggest advantage of using direct pointer access is its high speed, which saves the time overhead of pointer positioning.

4 key supplementary content

4.1 String classes and constant pools

1 two ways to create String objects

String str1= "abcd"; String str2 = new String ("abcd"); System.out.println (str1==str2); / / false

The two different creation methods are different, the first is to take the object in the constant pool, and the second is to create a new object directly in the heap memory space.

Remember: as long as you use the new method, you need to create a new object.

2 the constant pool of String type is special. There are two main ways to use it:

String objects declared directly in double quotes are stored directly in the constant pool.

If you are not a String object declared in double quotes, you can use the intern method provided by String. String.intern () is a Native method that returns a reference to the string in the constant pool if the runtime constant pool already contains a string equal to the content of the String object; if not, creates the same string in the constant pool as the String content and returns a reference to the string created in the constant pool.

String S1 = new String ("computer"); String S2 = s1.intern (); String S2 = "computer"; System.out.println (S2); / / computer System.out.println (S1 = = S2); / / false, because one is the String object in the heap memory and the other is the String object in the constant pool, System.out.println (S3 = = S2); / / true, because both are String objects in the constant pool

3 String string concatenation

String str1 = "str"; String str2 = "ing"; String str3 = "str" + "ing"; / / objects in the constant pool String str4 = str1 + str2; / / new objects created on the heap String str5 = "string"; / / objects in the constant pool System.out.println (str3 = = str4); / / falseSystem.out.println (str3 = = str5); / / trueSystem.out.println (str4 = str5); / / false

Try to avoid multiple string concatenation, as this will recreate the object. If you need to change the string, you can use StringBuilder or StringBuffer.

String S1 = new String ("abc"); / / how many objects are created by this sentence?

Two objects are created.

Verify:

String S1 = new String ("abc"); / / String S2 = "abc" of heap memory; System.out.println (S1 = = S2); / / output false, because one is heap memory and the other is constant pool memory, so the two are different. System.out.println (s1.equals (S2)); / / output true

Results:

Falsetrue

Explanation:

First the string "abc" is put into the constant pool, then new puts a copy of the string "abc" into the Java heap (the string constant "abc" is determined to be placed in the constant pool at compile time, while the "abc" on the Java heap is determined during the runtime initialization phase), and then the str1 of the Java stack points to "abc" on the Java heap.

4.28 basic types of wrapper classes and constant pools

Most of the wrapper classes of Java basic types implement constant pool technology, that is, Byte, Short, Integer, Long, Character, and Boolean; create corresponding types of cache data with a value of [- 128127] by default, but new objects will still be created beyond this range.

The two floating-point types of wrapper classes Float and Double do not implement constant pool technology.

Integer i1 = 33 falseDouble Integer i2 = 33 System.out.println (i1 = = i2); / / output falseDouble i11 = 333 th Integer i22 = 333 X system. Out.println (i11 = = i22); / / output System.out.println (i3 = = i4); / / output System.out.println (i3 = = i4)

Integer cache source code:

/ * this method will always cache values in the range-128 to 127 (including endpoints), and can cache other values outside this range. * / public static Integer valueOf (int I) {if (I > = IntegerCache.low & & I

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.