Summarize the knowledge points of the ten JVM modules. If you don't believe it, you still don't understand it

01 JVM  Memory structure

Java  The memory space of virtual machine is divided into two parts  5  Parts of ：

• Program counter

• Java  Virtual machine stack

• Native Method Stack

• Pile up

• Method area

JDK 1.8  Same as  JDK 1.7  Than , The biggest difference is ： Metadata area replaces permanent generation . The essence and permanence of meta space   Generational similarity , All right.  JVM  Implementation of method area in specification . But the biggest difference between Metaspace and permanent generation is ： The metadata space is not in the virtual machine , It's using local memory .

1.1  Program counter （PC  register ）

（1） Definition of program counter   A program counter is a small amount of memory , Is the location of the bytecode instruction that the current thread is executing   site . If the current thread is executing a local method , Then the program counter is  Undefined.

（2） The function of program counter

• Bytecode interpreter reads instructions in turn by changing program counter , So as to realize the flow control of the code .

• In the case of multithreading , The program counter records the current thread execution position , Thus, when the thread switches back to   when , I know where the thread last executed .

（3） Features of program counter    It's a small amount of memory .

• Thread private , Each thread has its own program counter .

• Life cycle ： Created with the creation of threads , Destroy as the thread ends .

• It's the only one that won't show up  OutOfMemoryError  The memory area of .

Because of the length of the article , The content of the Department will be shown in pictures , If you have a partner, you need to check the complete document, watch and like + After paying attention 【

Click here to

】 Can get ！！

1.2 Java  Virtual machine stack （Java  Stack ）

（1）Java  Definition of virtual machine stack  Java  Virtual machine stack is a description of  Java  The memory model of the method run .

Java  The virtual machine stack will run for each  Java  Method to create a block called “ Stack frame ” Region ,  It is used to store some information during the operation of the method , Such as ：

• Local variable table

• The stack of operands

• Dynamic links

• Method exit information

• ......

（2） Stack pressing process   When a local variable needs to be created during method operation , Store the value of the local variable into the local variable in the stack frame   In the scale .

Java  The stack frame at the top of the virtual machine stack is the active stack currently executing , That is, what is currently being implemented   Method ,PC  The register will also point to this address . Only the local variables of this active stack frame can be manipulated   Use as a stack , When we call another method in this stack frame , The corresponding stack frame will be created , new   The created stack frame is pressed into the top of the stack , Becomes the current active stack frame .

After the method is over , The current stack frame is moved out , The return value of the stack frame becomes one of the operand stacks in the new active stack frame   Operands . If there is no return value , Then the new active stack frame has no change in the operand stack .

because  Java  The virtual machine stack corresponds to threads , Data is not shared by threads , So don't worry about data   Consistency issues , There won't be a problem with synchronization locks .

（3）Java  The characteristics of virtual machine stack

• The local variable table is created as the stack frame is created , Its size is determined at compile time , Just allocate things when creating   You can specify the size first . During method operation , The size of the local variable table does not change .

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

• StackOverFlowError  if  Java  The size of the virtual machine stack does not allow dynamic expansion , Then when the thread please   The depth of the stack exceeds the current  Java  The maximum depth of the virtual machine stack , Throw out  StackOverFlowError  abnormal .

02 HotSpot  Exploring virtual machine objects

2.1  Memory layout of objects   stay  HotSpot  In the virtual machine , The memory layout of the object is divided into the following  3  area ：

• Object head （Header）

• The instance data （Instance Data）

• Alignment filling （Padding）

（1） Object head

The object header records some data that the object needs to use in the running process ：

• Hash code

• GC  Generational age

• Lock status flag

• A lock held by a thread

• To the thread  ID

• Bias timestamp

The object header may contain a type pointer , Through this pointer, you can determine which class the object belongs to . If the object is a   Array , Then the object header will also include the array length .

（2） The instance data

The instance data part is the value of the member variable , It includes parent class member variables and this class member variables .

（3） Alignment filling

Used to ensure that the total length of the object is  8  Integer multiples of bytes . HotSpot VM  The automatic memory management system of requires that the size of the object must be  8  Integer multiples of bytes . and   The object header is exactly  8  Multiple of bytes （1  Times or  2  times ）, therefore , When the object instance data Department   When the points are not aligned , It needs to be filled by aligning the padding .  Aligned padding does not necessarily exist , It doesn't mean anything , It's just a placeholder

03  Garbage collection strategy and algorithm

Program counter 、 Virtual machine stack 、 The native method stack is built with threads , It also dies with the thread ; Stack frame with method   The beginning of the stack , Stack as method ends . The memory allocation and recycling of these areas are accurate   qualitative , There is no need to think too much about recycling in these areas , Because the method ends or the thread ends   when , Memory naturally follows the recycling . And for  Java  Heap and method area , We only know what objects will be created when the program is running ,  This part of memory allocation and recycling are dynamic , This is what the garbage collector is focusing on .

3.1  Determine whether the object is alive

If an object is not referenced by any object or variable , So it's an invalid object , Need to be recycled .

（1） Reference counting

Maintain a... In the object header  counter  Counter , Object is referenced once counter  +1; If quoted   If it fails, the counter  -1. When the counter is  0  when , The object is considered invalid .

The implementation of reference counting algorithm is simple , It's also very efficient , In most cases, it is a good   Algorithm . But mainstream  Java  There is no reference counting algorithm in virtual machine to manage memory , Mainly because   It is difficult to solve the problem of circular reference between objects .

Take a chestnut object  objA  and  objB  All have fields  instance, Make  objA.instance = objB  also  objB.instance = objA, Because they refer to each other , The reference count that caused them   Not for  0, So the reference counting algorithm can't notify  GC  The collector recycles them .

（2） Accessibility analysis

All and  GC Roots  Objects that are directly or indirectly related are valid objects , and  GC Roots  It's not off   The associated object is an invalid object .

GC Roots  Refer to ：

• Java  Virtual machine stack （ Local variables in stack frames ） Object referenced in

• Objects referenced in the local method stack

• The object referenced by a constant in the method area

• Object referenced by a class static property in a method area

GC Roots  Objects referenced by objects in the heap... Are not included , So there's no problem with circular references .

04 HotSpot  Garbage collector

HotSpot  Virtual machines provide a variety of garbage collectors , Each collector has its own characteristics , Although I   We need to compare each collector , But not to pick out the best collector . We chose   Just the most suitable collector for specific applications .

4.1  A new generation of garbage collectors

（1）Serial  Garbage collector （ Single thread ）  Open only one  GC  Thread garbage collection , And stop all user threads during garbage collection  (Stop The World).

Generally, client applications need less memory , Not too many objects will be created , And the heap memory is small , So garbage   The collector recovery time is short , Even if all user threads are stopped during this time , I don't feel like a bright carton .  therefore  Serial  The garbage collector is suitable for the client .

because  Serial  The collector uses only one  GC  Threads , It avoids the overhead of thread switching , Thus simple and high   effect .

（2）ParNew  Garbage collector （ Multithreading ）

ParNew  yes  Serial  Multithreaded version of . By multiple  GC  Threads do garbage cleaning in parallel . but   The cleaning process still needs  Stop The World.

ParNew  Pursuit “ Low pause time ”, And  Serial  The only difference is the use of multithreading for garbage collection   Set , In a multiple  CPU  Performance ratio in environment  Serial  There will be a certain degree of improvement ; But thread switching requires an amount   Extra expenses , So in the single  CPU  Not as good as in the environment  Serial.

05  Memory allocation and recycling strategy

06 JVM  performance tuning

Deploy programs on high-performance hardware , At present, there are mainly two ways ：

• adopt  64  position  JDK  To use large memory ;

• Use several  32  Bit virtual machines build logical clusters to utilize hardware resources .

07  Class file structure

08  Class load time

09  The process of class loading

10  Class loader

10.1  Class and class loader

（1） Determine whether the class “ equal ”  Any class , Is established by the class loader that loads it and the class itself  Java  In the virtual machine   Uniqueness , Every classloader , All have a separate class namespace .

therefore , Compare two classes whether or not “ equal ”, Only before these two classes are loaded by the same class loader   It makes sense to mention , otherwise , Even if the two classes come from the same  Class  file , By the same virtual   Machine loading , As long as the classloaders that load them are different , Then these two classes must not be equal .  there “ equal ”, Include... That represents the class  Class  Object's  equals()  Method 、isInstance()  Fang   Return result of method , It also includes the use of  instanceof  Keywords are used to determine the relationship of objects .