Learn Java heap, method area, Java stack, and local method stack from several sample

Recently looking at "in-depth understanding of Java Virtual Machine", the book gives a few examples, better explain the process of several oom (OutOfMemory), most programmers do not pay too much attention to the Java Runtime data area structure when writing programs:

It feels necessary to deepen our understanding of these areas through a few real examples.

1) Java heap

The instance assignments for all objects are allocated memory on the Java heap, and the heap size is adjusted by-xmx and-XMS, as shown in sample:

[Java]View Plaincopyprint?

2. Public class Heapoom {
6. static class oomobject{}
10. /**
12. * @param args
14. */
16. public static void Main (string[] args) {
18. list<oomobject> list = new arraylist<oomobject> ();
22. While (true) {
24. List.add (new Oomobject ());
26. }
28. }
32. }

public class Heapoom {static Class oomobject{}/** * @param args */public static void main (string[] args) {List<oomobjec t> list = new arraylist<oomobject> (), while (true) {List.add (New Oomobject ());}}}

Plus the JVM parameter-verbose:gc-xms10m-xmx10m-xx:+printgcdetails-xx:survivorratio=8-xx:+heapdumponoutofmemoryerror, will be able to quote the Oom soon:

Exception in thread "main" Java.lang.OutOfMemoryError:Java heap space

and can automatically generate dump.

2) Method Area

The method area is the information that holds the virtual machine load class, such as classes, static variables and constants, the size is adjusted by-xx:permsize and-xx:maxpermsize, and too many classes have the potential to burst the permanent band:

[Java]View Plaincopyprint?

2. Public class Methodareaoom {
6. static class oomojbect{}
10. /**
12. * @param args
14. */
16. public static void Main (string[] args) {
18. //TODO auto-generated method stub
20. While (true) {
22. Enhancer eh = new enhancer ();
24. Eh.setsuperclass (oomojbect.   Class);
26. Eh.setusecache (false);
28. Eh.setcallback (new Methodinterceptor () {
32. @Override
34. Public Object Intercept (object arg0, Method arg1,
36. Object[] arg2, Methodproxy arg3) throws Throwable {
38. //TODO auto-generated method stub
40. return Arg3.invokesuper (arg0, arg2);
42. }
46. });
48. Eh.create ();
50. }
52. }
56. }

public class Methodareaoom {static Class oomojbect{}/** * @param args */public static void main (string[] args) {//TODO Au To-generated method Stubwhile (true) {enhancer eh = new enhancer (); Eh.setsuperclass (Oomojbect.class); Eh.setusecache ( FALSE); Eh.setcallback (new Methodinterceptor () {@Overridepublic object Intercept (object arg0, Method arg1,object[] Arg2 , Methodproxy Arg3) throws Throwable {//TODO auto-generated method Stubreturn arg3.invokesuper (arg0, arg2);}}); Eh.create ();}}}

With the JVM parameters of the permanent band:-xx:permsize=10m-xx:maxpermsize=10m, the following exception is reported after running:

Exception in thread "main" Java.lang.OutOfMemoryError:PermGen space

Static variables or constants also have the potential to explode the method area:

[Java]View Plaincopyprint?

2. Public class Constantoom {
6. /**
8. * @param args
10. */
12. public static void Main (string[] args) {
14. //TODO auto-generated method stub
16. list<string> list = new arraylist<string> ();
18. int i=0;
20. While (true) {
22. List.add (String.valueof (i++). Intern ());
24. }
26. }
30. }

public class Constantoom {/** * @param args */public static void main (string[] args) {//TODO auto-generated method Stubli st<string> list = new arraylist<string> (), int i=0;while (TRUE) {List.add (string.valueof (i++). Intern ());}}}

Also add the JVM parameter:-xx:permsize=10m-xx:maxpermsize=10m, the following exception is reported after running:

Exception in thread "main" Java.lang.OutOfMemoryError:PermGen space

3) Java stack and local method stack

Stack is to store the thread call method when storing local variables table, operation, method exit and other information related to the execution of the method, the stack size is adjusted by XSS, the method call hierarchy too much will burst this area, samples as follows:

[Java]View Plaincopyprint?

2. Package Com.cutesource;
6. Public class Stackoom {
10. /**
12. * @param args
14. */
18. private int stacklength = 1;
22. public void Stackleak () {
24. stacklength++;
26. Stackleak ();
28. }
32. public static void Main (string[] args) throws throwable{
34. //TODO auto-generated method stub
36. Stackoom oom = new Stackoom ();
38. try{
40. Oom.stackleak ();
42. }catch (Throwable err) {
44. System.out.println ("Stack length:" + oom.stacklength);
46. throw err;
48. }
52. }
56. }

Package Com.cutesource;public class Stackoom {/** * @param args */private int stacklength = 1;public void Stackleak () {Stac Klength++;stackleak ();} public static void Main (string[] args) throws throwable{//TODO auto-generated method Stubstackoom oom = new Stackoom (); TR Y{oom.stackleak ();} catch (Throwable err) {System.out.println ("Stack Length:" + oom.stacklength); throw err;}}}

Set JVM parameters:-xss128k, Report exception:

Exception in thread "main" Java.lang.StackOverflowError

Print out the stack length:1007, as you can see, the 128k stack capacity on my machine can carry a method call with a depth of 1007. Of course, this kind of error is seldom seen, usually only in the infinite loop recursion, in addition, too many threads will occupy the stack area:

[Java]View Plaincopyprint?

2. Package Com.cutesource;
6. Public class Stackoom {
10. /**
12. * @param args
14. */
18. private int stacklength = 1;
22. private void Dontstop () {
24. While (true) {
26. Try{thread.sleep (1000);} catch (Exception err) {}
28. }
30. }
34. public void Stackleakbythread () {
36. While (true) {
38. Thread t = new Thread (new Runnable () {
42. @Override
44. public Void Run () {
46. //TODO auto-generated method stub
48. Dontstop ();
50. }
54. });
56. T.start ();
58. stacklength++;
60. }
62. }
66. public static void Main (string[] args) throws throwable{
68. //TODO auto-generated method stub
70. Stackoom oom = new Stackoom ();
72. try{
74. Oom.stackleakbythread ();
76. }catch (Throwable err) {
78. System.out.println ("Stack length:" + oom.stacklength);
80. throw err;
82. }
86. }
90. }

Package Com.cutesource;public class Stackoom {/** * @param args */private int stacklength = 1;private void Dontstop () {Whil E (True) {try{thread.sleep (1000);} catch (Exception err) {}}}public void Stackleakbythread () {while (true) {thread t = new Thread (new Runnable () {@ overridepublic void Run () {//TODO auto-generated method Stubdontstop ();}); T.start (); stacklength++;}} public static void Main (string[] args) throws throwable{//TODO auto-generated method Stubstackoom oom = new Stackoom (); TR Y{oom.stackleakbythread ();} catch (Throwable err) {System.out.println ("Stack Length:" + oom.stacklength); throw err;}}}

Report exception: Exception in thread "main" java.lang.OutOfMemoryError:unable to create new native thread

However, to run this example on Windows, be careful, there will be a system of suspended animation, it may be necessary to restart the machine.

The above few examples are simple, but they can help the average programmer to understand the Java heap , the method area , theJava stack and the local method stack more intuitively.

Learn Java heap, method area, Java stack, and local method stack from several sample