The underlying data type is directly allocated in the stack space, and the form parameters of the method are allocated directly in the stack space when the method call is completed and reclaimed from the stack space. The reference data type needs to be created with new, which allocates an address space in the stack space and allocates the class variables of the object in the heap space. The reference parameter of the method, which allocates an address space in the stack space, and points to the object area of the heap space, which is reclaimed from the stack space when the method call is complete. When the local variable new comes out, allocates space in the stack space and heap space, when the local variable life cycle ends, the stack space is immediately reclaimed, and the heap space area waits for GC to reclaim. The literal parameter passed in when the method is called, first allocated in the stack space, and then allocated from the stack space after the method call is complete. String constants are allocated in the DATA area, this is allocated in heap space. Arrays are both allocated in the stack space and the actual size of the array is allocated in the heap space!
Oh, by the way, add static to the data area assignment.
From this allocation mechanism in Java, the stack can be understood as a stack is a storage area that the operating system establishes for a process, or a thread (a thread in a multithreaded operating system) for this thread, which has an advanced post-out feature.
Each Java application uniquely corresponds to a single JVM instance, and each instance uniquely corresponds to one heap. All instances or arrays of classes created by the application in the run are placed in this heap and shared by all threads of the application. Unlike C + +, allocating heap memory is automatically initialized in Java. The storage space for all objects in Java is allocated in the heap, but the reference to this object is allocated on the stack, that is, allocating memory from two places when an object is built, memory allocated in the heap actually establishes the object, and the memory allocated on the stack is just a pointer to the heap object (reference) Only.
< two >
These two days to look at the understanding of the JVM this book, recommended to advanced Java programmers to see, to you understand Java's underlying and operating mechanism has
A big help.
Nonsense don't want to talk about. Into the topic:
First understand the specific concepts:
Java's JVM memory can be divided into 3 zones: heap, stack (stack), and method area
Heap Area:
1. All objects are stored, each containing a class-corresponding information. (The purpose of class is to get operation instructions)
2.JVM only one heap area (heap) is shared by all threads, and the heap does not hold basic types and object references, only the object itself
Stack area:
1. Each thread contains a stack where only objects of the underlying data type are saved and references to custom objects (not objects), objects are stored in the heap area
2. The data in each stack (original type and object reference) is private and other stacks are inaccessible.
3. The stack is divided into 3 parts: the basic type variable area, the execution environment context, the operation instruction area (holds the operation instruction).
Method Area:
1. Also called the static zone, like the heap, is shared by all threads. The method area contains all class and static variables.
2. The method area contains elements that are always unique throughout the program, such as the class,static variable.
To get a clearer picture of what's going on in the runtime data area, let's prepare 2 props (2 very simple small programs).
PackageCOM.JAVA.JVM; Public classSample//at runtime, the JVM puts Appmain information into the method area{ /**Example Name*/ PrivateString name;//After the new sample instance, the name reference is placed in the stack, and the name object is placed in the heap /**Construction Method*/ PublicSample (String name) { This. Name =name; } /**Output*/ Public voidPrintname ()//The Print method itself is placed in the method area. {System.out.println (name); }}
PackageCOM.JAVA.JVM; Public classAppmain//at runtime, the JVM puts Appmain information into the method area{ Public Static voidMain (string[] args)//The Main method itself is put into the method area. {Sample test1=NewSample ("Test 1");//Test1 is a reference, so put it in the stack area,//sample is a custom object that should be placed inside the heapSample test2 =NewSample ("Test 2"); Test1.printname (); Test2.printname (); }}
OK, let's get started, the departure command is: "Java appmain", bag with our action Guide diagram, lets ' s go!
The system received our instructions and started a Java Virtual machine process, which first finds the Appmain.class file from Classpath, reads the binary data from the file, and then stores the class information of the Appmain class in the method area of the runtime data area. This process is called the Appmain class's loading process.
The Java virtual machine then navigates to the bytecode of the main () method of the Appmain class in the method area and starts executing its instructions. The first statement of the main () method is:
Sample Test1=new sample ("Test 1");
The simple statement is to have the Java Virtual machine Create a sample instance, and to make the reference variable Test1 reference the instance. Looks like a small case a pile oh, let us follow the Java virtual machine, see how it is to perform this task:
1, Java Virtual machine A look, is not to establish a sample instance, simple, so go straight to the method area, first find the type of sample class information. As a result, hey, did not find @@, at the moment the method area has no sample class yet. Java Virtual machine is not a rib of the idiot, so, it carry forward the "hands-on, clothed" style, immediately loaded the sample class, the type of sample class information stored in the method area.
2, good, the information found, the following began to work. The first thing a Java virtual machine does is toThe heap area allocates memory for a new sample instance that holds a reference to the type information of the sample class of the method area. Here is the reference,Actually refers to the sample class type information in the method area of the memory address, in fact, is a bit similar to the C language pointer ~ ~, and this address, it is stored in the sample instance data area.
3, in the Java Virtual machine process, each thread will have a method call stack, used to track the thread run in a series of method call procedures, each element of the stack is called a stack frame, each time the thread calls a method, the method stack is pressed into a new frame. The frames here are used to store the parameters of the method, local variables, and temporary data during the operation. OK, the principle is finished, let us continue our follow-up action! The Test1 in front of "=" is a variable defined in the main () method, which is visible as a local variable, so it is added to the Java method call stack that executes the main thread of the main () method. The "=" will point this test1 variable to the sample instance in the heap area, which means it holds a reference to the sample instance.
OK, so far, the Java Virtual machine has completed the task of executing this simple statement. Referring to our action guide diagram, we finally got a little bit of the Java Virtual machine, cool!
Next, the Java Virtual machine continues with subsequent instructions, continues to create another sample instance in the heap area, and then executes their printname () method in turn. When the Java virtual machine executes the Test1.printname () method, the Java virtual machine navigates to the sample instance in the heap based on the reference held by the local variable test1, and then navigates to the type information of the sample class in the method according to the reference held by the sample instance. The byte code of the Printname () method is obtained, followed by the instructions contained in the Printname () method.
< three >
When using TaskManager in Windows to view the memory used by the Java process, it is sometimes found to exceed the size of-XMX's memory,-XMX specifies that Java Heap,java also allocates memory to do other things, including building stacks for each thread.
Each thread of the VM has its own stack space, the size of the stack space limits the number of threads in the VM, is too large, the number of practical threads is reduced, and the java.lang.StackOverflowError exception is too small to throw easily. Windows default to 1m,linux must run ulimit-s 2048.
The difference between heap and stack (stack) in C language
The simple can be understood as:
Heap: Is the location of space allocated by functions such as malloc. The address is increased from low to high.
Stack: Is the automatic allocation of variables, as well as some of the space used when the function is called. The address is reduced by a high-to-low.
The memory used by a program compiled by C + + is divided into the following sections
1. Stack (stack)-Automatically allocated by the compiler to release, store the function parameter value, local variable value and so on. It operates in a manner similar to a stack in a data structure.
2. The difference between heap and stack (stack) in the Java language
1. Stacks and heaps (heap) are places that Java uses to store data in RAM. Unlike C + +, Java automatically manages stacks and heaps, and programmers cannot directly set up stacks or heaps.
2. The advantage of the stack is that the access speed is faster than the heap, second only to the registers directly in the CPU. However, the disadvantage is that the size and lifetime of the data in the stack must be deterministic and inflexible. In addition, the stack data can be shared, see 3rd. The advantage of the heap is that the memory size can be allocated dynamically, and the lifetime does not have to tell the compiler beforehand that the Java garbage collector automatically collects the data that is no longer in use. However, the disadvantage is that the access speed is slower due to the dynamic allocation of memory at run time.
3. There are two kinds of data types in Java.
One is the basic type (primitive types), a total of 8 kinds, namely int, short, long, byte, float, double, Boolean, char (note, and no basic type of string). The definition of this type is through such as int a = 3; Long B = 255L; the form to be defined, called an automatic variable. It is worth noting that the automatic variable is a literal value, not an instance of a class, that is not a reference to a class, there is no class here. such as int a = 3; Here A is a reference to the int type, pointing to the literal value of 3. The data of these literals, due to the size of the known, the lifetime of the known (these values are fixed in a program block, the program block exits, the field value disappears), for the sake of speed, it exists in the stack.
Other than thatStack has a very important particularity, is that there is data in the stack can be shared. Suppose we both define
int a = 3;
int b = 3;
The compiler processes int a = 3 First, it creates a reference to a variable in the stack, and then looks for an address with a literal value of 3, finds an address that holds the literal value of 3, and then points A to the address of 3. then the int b = 3 is processed, and after the reference variable of B is created, B is pointed directly to the address of 3 because there are already 3 literals in the stack. In this case, A and B both point to 3.
It is particularly important to note that the reference to this literal is different from the reference to the class object. Assuming that a reference to two class objects points to an object at the same time, if an object reference variable modifies the internal state of the object, then another object reference variable will immediately reflect that change. Conversely, modifying its value by a reference to a literal value does not result in another case where a reference to that literal is changed. As in the example above, we define the value of a and B and then make a=4; then B will not be equal to 4 or equal to 3. Inside the compiler, when it encounters A=4, it will re-search the stack for a literal value of 4, and if not, re-open the value of the address 4, and if so, point a directly at the address. Therefore the change of a value does not affect the value of B.
The other is the wrapper class data, such as Integer, String, double, and so on, the corresponding basic data types are wrapped up class. These classes of data all exist in the heap, and Java uses the new () statement to tell the compiler that it is dynamically created as needed at run time, so it is more flexible, but the disadvantage is that it takes more time.
4.Each JVM thread has its own private stack space, created with thread creation, Java stack holds frames, Java stack and C are different, just store local variables, return values and call methods, do not allow direct push and pop frames, Because frames may be allocated in heap, the memory allocated by J for Ava's stack does not need to be contiguous. Java's heap is shared by all threads, and the heap holds all runtime data, which is all object instances and arrays, and the heap is created when the JVM is started.
5. String is a special wrapper class data. That is, it can be created in the form of string str = new String ("abc"), or in the form of string str = "abc" (In contrast, before JDK 5.0, you have never seen an expression of integer i = 3; because class and literal literals are not can be generic except for string. In JDK 5.0, this expression is possible! Because the compiler is converting the integer i = new Integer (3) in the background. The former is the process of creating a canonical class, that is, in Java, everything is an object, and the object is an instance of the class, all created in the form of new (). Some classes in Java, such as the DateFormat class, can return a newly created class through the class's getinstance () method, which seems to violate this principle. actually otherwise The class uses a singleton pattern to return an instance of the class, except that the instance is created inside the class through new (), and getinstance () hides this detail from the outside. So why is the case in string str = "abc", not created by new (), a violation of the above principle? Not really.
5. About the internal work of string str = "abc". Inside Java, this statement is translated into the following steps:
(1) First define an object reference variable named str to the String class: String str;
(2) in the stack to find whether there is a value of "ABC" address, if not, then open a store with a literal "ABC" address, then create a new String Class object O, and the string value of O point to the address, and in the stack next to this address note the referenced object o. If you already have an address with a value of "ABC", look for the object o and return the address of O.
(3) Point Str to the address of the object o.
It is important to note that the string values in the generic string class are directly stored values. But like string str = "abc"; in this case, its string value is saved by aA reference to the data that exists on the stack!
To better illustrate this problem, we can verify it by following several code.
String str1 = "abc";
String str2 = "abc";
System.out.println (STR1==STR2); True
Note that we do not use Str1.equals (STR2) in this way, as this will compare the values of two strings for equality. = = number, as described in the JDK, returns true only if two references point to the same object. And what we're looking at here is whether str1 and str2 all point to the same object.
The result shows that the JVM created two references str1 and str2, but only one object was created, and two references pointed to the object.
Let's go further and change the above code to:
String str1 = "abc";
String str2 = "abc";
str1 = "BCD";
System.out.println (str1 + "," + str2); BCD, ABC
System.out.println (STR1==STR2); False
This means that the change in the assignment has led to a change in the class object reference, and str1 points to another new object! And str2 still points to the original object. In the example above, when we change the value of str1 to "BCD", the JVM discovers that there is no address for that value in the stack, opens up this address and creates a new object whose string value points to the address.
In fact, the string class is designed to be immutable (immutable) classes. If you want to change its value, yes, but the JVM silently creates a new object at run time based on the new value, and then returns the address of the object to the reference of the original class. This creation process is entirely automatic, but it takes up more time. In the environment that is more sensitive to time requirements, it will have some adverse effects.
Then modify the original code:
String str1 = "abc";
String str2 = "abc";
str1 = "BCD";
String STR3 = str1;
System.out.println (STR3); Bcd
String STR4 = "BCD";
System.out.println (str1 = = STR4); True
STR3 a reference to this object points directly to the object that str1 points to (note that STR3 does not create a new object). When str1 changes its value, it creates a reference str4 of string and points to the new object created by str1 modifying the value. It can be found that this time STR4 also did not create a new object, thereby re-sharing the data in the stack.
Let's look at the following code again.
String str1 = new String ("abc");
String str2 = "abc";
System.out.println (STR1==STR2); False
Two references were created. Two objects were created. Two references point to a different two objects, respectively.
String str1 = "abc";
String str2 = new String ("abc");
System.out.println (STR1==STR2); False
Two references were created. Two objects were created. Two references point to a different two objects, respectively.
The above two code shows that as long as new () is used to create the object, it is created in the heap, and its string is stored separately, even if the data in the stack is the same, it is not shared with the data in the stack.
6. The value of the data type wrapper class cannot be modified. Not only the value of the string class cannot be modified, but all data type wrapper classes cannot change their internal values.
7. CONCLUSIONS AND RECOMMENDATIONS:
(1) When we use a format definition class such as String str = "ABC", we always want to think of course that we created the object str of the String class. Worry about traps! The object may not have been created! The only certainty is that a reference to the string class was created. As to whether the reference is pointing to a new object, it must be considered in terms of context, unless you create a new object with a prominent way through the new () method. Therefore, it is more accurate to say that we have created a reference variable to the object of the String class str, which refers to a variable that points to a string class with the value "ABC". Being aware of this is helpful in troubleshooting bugs that are difficult to find in a program.
(2) The use of string str = "abc", in a way that can improve the speed of the program to a certain extent, because the JVM will automatically based on the actual data in the stack to determine whether it is necessary to create a new object. In the case of string str = new String ("abc"), the code creates a new object in the heap, regardless of whether the string value is equal or not, and it is necessary to create a new object, thereby aggravating the burden of the program. This idea should be the idea of the meta-mode, but it is not known whether the internal JDK implements this pattern.
(3) Use the Equals () method when comparing the values in the wrapper class, and use the = = when testing whether the references to the two wrapper classes point to the same object.
(4) Because of the immutable nature of the string class, you should consider using the StringBuffer class when the string variable needs to change its value frequently to improve program efficiency.
If Java cannot successfully allocate the heap space, the OutOfMemoryError will be thrown
Heap stack (stack) and method area (methods) in Java
