精华内容
下载资源
问答
  • 主要介绍了java 内存和栈内存的知识,有需要的朋友可以参考下
  • 详细的讲解了java内存分配,包括运行时堆和栈内存的分配,变量方法存储等
  • 主要介绍了JAVA中堆内存与栈内存的区别,文中讲解非常细致,代码帮助大家更好的理解学习,感兴趣的朋友可以了解下
  • 主要介绍了Java内存与栈内存的存储机制,包括JVM的内存优化GC等相关方面内容,需要的朋友可以参考下
  • 在本篇文章里小编给大家整理的是关于java中堆内存与栈内存的知识点总结,有需要的朋友们可以跟着学习下。
  • Java堆内存和栈内存

    2020-12-22 15:22:30
     在函数中定义的一些基本类型的变量对象的引用变量都是在函数的栈内存中分配。当在一段代码块中定义一个变量时,java在栈中为这个变量分配内存空间,当超过变量的作用域后,java会自动释放掉为该变量分配的内存...
  • java堆内存和栈内存的区别

    万次阅读 多人点赞 2017-06-05 14:48:57
    Java中你会看到很多堆和栈内存的引用,JavaEE书文章很难在程序的角度完全解释什么是什么是栈。 Java堆内存 内存在Java运行时被使用来为对象JRE类分配内存。不论什么时候我们创建了对象,它将一直会在...

    一段时间之前,我写了两篇文章文章分别是Java的垃圾回收和Java的值传递,从那之后我收到了很多要求解释Java堆内存和栈内存的邮件,并且要求解释他们的异同点。

    在Java中你会看到很多堆和栈内存的引用,JavaEE书和文章很难在程序的角度完全解释什么是堆什么是栈。


    总结:
    1 栈:为编译器自动分配和释放,如函数参数、局部变量、临时变量等等
    2 堆:为成员分配和释放,由程序员自己申请、自己释放。否则发生内存泄露。典型为使用new申请的堆内容。
    除了这两部分,还有一部分是:
    3 静态存储区:内存在程序编译的时候就已经分配好,这块内存在程序的整个运行期间都存在。它主要存放静态数据、全局数据和常量。



    Java堆内存

    堆内存在Java运行时被使用来为对象和JRE类分配内存。不论什么时候我们创建了对象,它将一直会在堆内存上创建。垃圾回收运行在堆内存上来释放没有任何引用的对象所占的内存,任何在堆上被创建的对象都有一个全局的访问,并且可以在应用的任何位置被引用。

    Java栈内存

    Java的栈内存被用来线程的执行,他们包含生命周期很短的具体值的方法和在堆中使用这个方法对象的引用。栈内存是LIFO(后进先出)序列。当方法被调用的时候,堆内存中一个新的块被创建,保存了本地原始值和在方法中对其他对象的引用。这个方法结束之后,这个块对其他方法就变成可用的了。栈内存与堆内存相比是非常小的。
    我们用下边的例子理解堆内存和栈内存
    1. package com.journaldev.test;  
    2.    
    3. public class Memory {  
    4.    
    5.     public static void main(String[] args) { // Line 1  
    6.         int i=1// Line 2  
    7.         Object obj = new Object(); // Line 3  
    8.         Memory mem = new Memory(); // Line 4  
    9.         mem.foo(obj); // Line 5  
    10.     } // Line 9  
    11.    
    12.     private void foo(Object param) { // Line 6  
    13.         String str = param.toString();  Line 7  
    14.         System.out.println(str);  
    15.     } // Line 8  
    16.    
    17. }  

    下边的图片展示了上边程序堆和栈内存的引用,并且是怎么用来存储原始值、对象和变量的引用。


    我们来看看程序执行的过程:
    1、只要我们一运行这个程序,它会加载所有的运行类到堆内存中去,当在第一行找到main()方法的时候,Java创建可以被main()方法线程使用的栈内存。
    2、当在第一行,我们创建了本地原始变量,它在main()的栈中创建和保存。
    3、因为我们在第三行创建了对象,它在堆内存中被创建,在栈内存中保存了它的引用,同样的过程也发生在第四行我们创建Memory对象的时候。
    4、当在第五行我们调用foo()方法的时候,在堆的顶部创建了一个块来被foo()方法使用,因为Java是值传递的,在第六行一个新的对象的引用在foo()方法中的栈中被创建
    5、在第七行一个String被创建,它在堆空间中的 String池中运行,并且它的引用也在foo()方法的栈空间中被创建
    6、foo()方法在第八行结束,此时在堆中为foo()方法分配的内存块可以被释放
    7、在第九行,main()方法结束,栈为main()方法创建的内存空间可以被销毁。同样程序也在行结束,Java释放了所有的内存,结束了程序的运行

    堆内存和栈内存的区别

    基于上边的解释我们可以很简单的总结出堆和栈的区别:
    1、应用程序所有的部分都使用堆内存,然后栈内存通过一个线程运行来使用。
    2、不论对象什么时候创建,他都会存储在堆内存中,栈内存包含它的引用。栈内存只包含原始值变量好和堆中对象变量的引用。
    3、存储在堆中的对象是全局可以被访问的,然而栈内存不能被其他线程所访问。
    4、栈中的内存管理使用LIFO的方式完成,而堆内存的管理要更复杂了,因为它是全局被访问的。堆内存被分为,年轻一代,老一代等等,更多的细节请看, 这篇文章
    5、栈内存是生命周期很短的,然而堆内存的生命周期从程序的运行开始到运行结束。
    6、我们可以使用-Xms和-Xmx JVM选项定义开始的大小和堆内存的最大值,我们可以使用-Xss定义栈的大小
    7、当栈内存满的时候,Java抛出java.lang.StackOverFlowError异常而堆内存满的时候抛出java.lang.OutOfMemoryError: Java Heap Space错误
    8、和堆内存比,栈内存要小的多,因为明确使用了内存分配规则(LIFO),和堆内存相比栈内存非常快。

    原文地址:http://www.journaldev.com/4098/java-heap-memory-vs-stack-memory-difference

    展开全文
  • 偶然看到一道面试题,Java在实例化一个类的时候,数据在堆和栈中是如何存放的?  public class A{  public int i=1;  public static A a1 = new A();  public static void mian(String args[]){  int c = ...
  • 本文分析了Java中堆内存与栈内存分配的异同
  • Java中堆内存和栈内存有什么区别

    千次阅读 2018-05-19 23:17:26
    Java把内存分成两种,一种叫做栈内存,一种叫做内存在函数中定义的一些基本类型的变量对象的引用变量都是在函数的栈内存中分配。当在一段代码块中定义一个变量时,java就在栈中为这个变量分配内存空间,当超过...

    Java把内存分成两种,一种叫做栈内存,一种叫做堆内存

    在函数中定义的一些基本类型的变量和对象的引用变量都是在函数的栈内存中分配。当在一段代码块中定义一个变量时,java就在栈中为这个变量分配内存空间,当超过变量的作用域后,java会自动释放掉为该变量分配的内存空间,该内存空间可以立刻被另作他用。

    堆内存用于存放由new创建的对象和数组。在堆中分配的内存,由java虚拟机自动垃圾回收器来管理。在堆中产生了一个数组或者对象后,还可以在栈中定义一个特殊的变量,这个变量的取值等于数组或者对象在堆内存中的首地址,在栈中的这个特殊的变量就变成了数组或者对象的引用变量,以后就可以在程序中使用栈内存中的引用变量来访问堆中的数组或者对象,引用变量相当于为数组或者对象起的一个别名,或者代号。

    引用变量是普通变量,定义时在栈中分配内存,引用变量在程序运行到作用域外释放。而数组&对象本身在堆中分配,即使程序运行到使用new产生数组和对象的语句所在地代码块之外,数组和对象本身占用的堆内存也不会被释放,数组和对象在没有引用变量指向它的时候,才变成垃圾,不能再被使用,但是仍然占着内存,在随后的一个不确定的时间被垃圾回收器释放掉。这个也是java比较占内存的主要原因,实际上,栈中的变量指向堆内存中的变量,这就是 Java 中的指针!

     

    java中内存分配策略及堆和栈的比较 

      1内存分配策略 

      按照编译原理的观点,程序运行时的内存分配有三种策略,分别是静态的,栈式的和堆式的。 

      静态存储分配是指在编译时就能确定每个数据目标,因而在编译时就可以给他们。这种分配策略要求程序代码中不允许(比如可变数组)的存在,也不允许有嵌套或者递归的结构,因为它们都会导致编译程序无法计算。 

      栈式存储分配也可称为动态,是由一个类似于堆栈的运行栈来实现的。和静态存储分配相反,在栈式存储方案中,程序对数据区的需求在编译,只有到运行的时候才能够知道,但是规定在运行中进入一个程序模块时,必须知道该程序模块所需的数据。和我们在数据结构所熟知的,栈式存储分配按照先进后出。 

      静态存储分配要求在编译时能,栈式存储分配要求在过程的,而堆式存储分配则专门负责在编译时或,比如可变长度串和对象实例。堆由大片的可利用块或,堆中的内存可以按照任意顺序分配和释放。 

      2堆和栈的比较 

      上面的定义从编译原理的教材中总结而来,除静态存储分配之外,都显得很呆板和难以理解,下面撇开静态存储分配,集中比较堆和栈: 

      从堆和栈的功能和作用来通俗的比较,堆主要用来存放对象的,栈主要是用来执行程序的而这种不同又主要是由于堆和: 

      在编程中,例如C / C ++中,所有的方法调用都是通过栈来进行的,所有的局部变量,形式参数都是从栈中分配内存空间的。实际上也不是什么分配,只是从栈顶向上用就行,就好像工厂中的传送带(传送带)一样,Stack Pointer会自动指引你到放东西的位置,你所要做的只是把东西放下来就行。退出函数的时候,修改栈指针就可以把栈中的内容销毁。这样的模式速度最快,当然要用来运行程序了。需要注意的是,在分配的时候,比如为一个即将要调用的程序模块分配数据区时,应事先知道这个数据区的大小,也就说是虽然分配是在程序运行时进行的,但是分配的大小多少是确定的,不变的,而这个“大小多少”是在编译时确定的,不是在运行时, 

      堆是应用程序在运行的时候请求操作系统分配给自己内存,由于从操作系统管理的内存分配,所以在分配和销毁时都要占用时间,因此用堆的 。率非常低但是堆的优点在于,编译器不必知道要从堆里分配多少存储空间,也不必知道存储的数据要在堆里停留多长的时间,因此,用堆保存数据时会得到更大的灵活性。事实上,面向对象的多态性,堆内存分配是必不可少的,因为多态变量所需的存储空间只有在运行时创建了对象之后才能确定。在C ++中,要求创建一个对象时,只需用新命令编制相关的代码即可。执行这些代码时,会在堆里自动进行数据的保存。当然,为达到这种灵活性,必然付出一定的代价:在堆里分配存储空间时会花掉更长的时间!这也正是导致我们刚才所说的效率低的原因,看来列宁同志说的好,人的优点往往也是人的缺点,人的缺点往往也是人的优点(晕〜)。 

      3 JVM中的堆和栈 

      JVM是基于堆栈的虚拟机.JVM为每个新创建的线程都分配一个堆栈。也就是说,对于一个Java程序来说,它的运行就是通过对堆栈的操作来完成的堆栈以帧为单位保存线程的状态.JVM对堆栈只进行两种操作:以帧为单位的压栈和出栈操作。 

      我们知道,某个线程正在执行的方法称为此线程的当前方法。我们可能不知道,当前方法使用的帧称为当前帧。当线程激活一个Java方法,JVM就会在线程的Java堆栈里新压入一个帧。这个帧自然成为了当前帧。在此方法执行期间,这个帧将用来保存参数,局部变量,中间计算过程和其他数据。这个帧在这里和编译原理中的活动纪录的概念是差不多的。 

      从Java的的这种分配机制来看,堆栈又可以这样理解:堆栈(栈)是操作系统在建立某个进程时或者线程(在支持多线程的操作系统中是线程)为这个线程建立的存储区域,该区域具有先进后出的特性。 

      每一个Java的应用都唯一对应一个JVM实例,每一个实例唯一对应一个堆。应用程序在运行中所创建的所有类实例或数组都放在这个堆中,并由应用所有的线程共享。跟C / C ++不同,爪哇中分配堆内存是自动初始化的的.java中所有对象的存储空间 是在堆中分配的,但是这个对象的引用却是在堆栈中分配,也就是说在建立一个对象时从两个地方都分配内存,在堆中分配的内存实际建立这个对象,而在堆栈中分配的内存只是一个指向这个堆对象的指针(引用) 

      而已。Java中的堆和栈 

      Java把内存划分成两种:一种是栈内存,一种是堆内存。 

      在函数中定义的一些基本类型的变量和对象的引用变量都在函数的栈内存中分配。 

      当在一段代码块定义一个变量时,Java的就在栈中为这个变量分配内存空间,当超过变量的作用域后,Java的会自动释放掉为该变量所分配的内存空间,该内存空间可以立即被另作他用。 

      堆内存用来存放由新创建的对象和数组。 

      在堆中分配的内存,由Java的虚拟机的自动垃圾回收器来管理。 

      在堆中产生了一个数组或对象后,还可以在栈中定义一个特殊的变量,让栈中这个变量的取值等于数组或对象在堆内存中的首地址,栈中的这个变量就成了数组或对象的引用变量。 

      引用变量就相当于是为数组或对象起的一个名称,以后就可以在程序中使用栈中的引用变量来访问堆中的数组或对象。 

      具体的说: 

      栈与堆都是Java用来在Ram中存放数据的地方。与C ++不同,Java自动管理栈和堆,程序员不能直接设置栈或堆 

      。Java的堆是一个运行时数据区,类的(对象从中分配空间。这些对象通过新的,newarray,anewarray和multianewarray等指令建立,它们不需要程序代码来显式的释放。堆是由垃圾回收来负责的,堆的优势是可以动态地分配内存大小,生存期也不必事先告诉编译器,因为它是在运行时动态分配内存的,Java的的垃圾收集器会自动收走这些不再使用的数据。但 点是,由于要在运行时动态分配内存,存取速度较慢。 

      栈的优势是,存取速度比堆要快,仅次于寄存器,栈数据可以共享。但缺点是,存在栈中的数据大小与生存期必须是确定的,缺乏灵活性。栈中主要存放一些基本类型的变量(,整型,短,长,字节,浮点,双精度,布尔值,炭)和对象句柄。 

      栈有一个很重要的特殊性,就是存在栈中的数据可以共享。假设我们同时定义: 

      int a = 3; 

      int b = 3; 

      编译器先处理int a = 3;首先它会在栈中创建一个变量为a的引用,然后查找栈中是否有3这个值,如果没找到,就将3存放进来,然后将a指向3.接着处理int b = 3;在创建完b的引用变量后,因为在栈中已经有3这个值,便将b直接指向3.这样,就出现了a与b同时均指向3的情况。这时,如果再令一个= 4;那么编译器会重新搜索栈中是否有4值,如果没有,则将4存放进来,并令一个指向4;如果已经有了,则直接将一个指向这个地址因此一值的改变不会影响到b的值。要注意这种数据的共享与两个对象的引用同时指向一个对象的这种共享是不同的,因为这种情况一个的修改并不会影响到b,它是由编译器完成的,它有利于节省空间。而一个对象引用变量修改了这个对象的内部状态,会影响到另一个对象引用变量 

    展开全文
  • 主要介绍了Java 内存与栈内存详细介绍的相关资料,这里对java内存和栈内存进行了详细的分析,需要的朋友可以参考下
  • JAVA内存和栈内存的区别

    千次阅读 2018-01-25 12:30:45
    Java把内存分成两种,一种叫做栈内存,一种叫做内存在函数中定义的一些基本类型的变量对象的引用变量都是在函数的栈内存中分配。当在一段代码块中定义一个变量时,java就在栈中为这个变量分配内存空间,当超过...

    转自http://blog.csdn.net/as02446418/article/details/47007975
    Java把内存分成两种,一种叫做栈内存,一种叫做堆内存

    在函数中定义的一些基本类型的变量和对象的引用变量都是在函数的栈内存中分配。当在一段代码块中定义一个变量时,java就在栈中为这个变量分配内存空间,当超过变量的作用域后,java会自动释放掉为该变量分配的内存空间,该内存空间可以立刻被另作他用。
    堆内存用于存放由new创建的对象和数组。在堆中分配的内存,由java虚拟机自动垃圾回收器来管理。在堆中产生了一个数组或者对象后,还可以在栈中定义一个特殊的变量,这个变量的取值等于数组或者对象在堆内存中的首地址,在栈中的这个特殊的变量就变成了数组或者对象的引用变量,以后就可以在程序中使用栈内存中的引用变量来访问堆中的数组或者对象,引用变量相当于为数组或者对象起的一个别名,或者代号。
    引用变量是普通变量,定义时在栈中分配内存,引用变量在程序运行到作用域外释放。而数组&对象本身在堆中分配,即使程序运行到使用new产生数组和对象的语句所在地代码块之外,数组和对象本身占用的堆内存也不会被释放,数组和对象在没有引用变量指向它的时候,才变成垃圾,不能再被使用,但是仍然占着内存,在随后的一个不确定的时间被垃圾回收器释放掉。这个也是java比较占内存的主要原因,实际上,栈中的变量指向堆内存中的变量,这就是 Java 中的指针!

    java中内存分配策略及堆和栈的比较

      1 内存分配策略

      按照编译原理的观点,程序运行时的内存分配有三种策略,分别是静态的,栈式的,和堆式的.

      静态存储分配是指在编译时就能确定每个数据目标在运行时刻的存储空间需求,因而在编译时就可以给他们分配固定的内存空间.这种分配策略要求程序代码中不允许有可变数据结构(比如可变数组)的存在,也不允许有嵌套或者递归的结构出现,因为它们都会导致编译程序无法计算准确的存储空间需求.

      栈式存储分配也可称为动态存储分配,是由一个类似于堆栈的运行栈来实现的.和静态存储分配相反,在栈式存储方案中,程序对数据区的需求在编译时是完全未知的,只有到运行的时候才能够知道,但是规定在运行中进入一个程序模块时,必须知道该程序模块所需的数据区大小才能够为其分配内存.和我们在数据结构所熟知的栈一样,栈式存储分配按照先进后出的原则进行分配。

      静态存储分配要求在编译时能知道所有变量的存储要求,栈式存储分配要求在过程的入口处必须知道所有的存储要求,而堆式存储分配则专门负责在编译时或运行时模块入口处都无法确定存储要求的数据结构的内存分配,比如可变长度串和对象实例.堆由大片的可利用块或空闲块组成,堆中的内存可以按照任意顺序分配和释放.

      2 堆和栈的比较

      上面的定义从编译原理的教材中总结而来,除静态存储分配之外,都显得很呆板和难以理解,下面撇开静态存储分配,集中比较堆和栈:

      从堆和栈的功能和作用来通俗的比较,堆主要用来存放对象的,栈主要是用来执行程序的.而这种不同又主要是由于堆和栈的特点决定的:

      在编程中,例如C/C++中,所有的方法调用都是通过栈来进行的,所有的局部变量,形式参数都是从栈中分配内存空间的。实际上也不是什么分配,只是从栈顶向上用就行,就好像工厂中的传送带(conveyor belt)一样,Stack Pointer会自动指引你到放东西的位置,你所要做的只是把东西放下来就行.退出函数的时候,修改栈指针就可以把栈中的内容销毁.这样的模式速度最快, 当然要用来运行程序了.需要注意的是,在分配的时候,比如为一个即将要调用的程序模块分配数据区时,应事先知道这个数据区的大小,也就说是虽然分配是在程序运行时进行的,但是分配的大小多少是确定的,不变的,而这个”大小多少”是在编译时确定的,不是在运行时.

      堆是应用程序在运行的时候请求操作系统分配给自己内存,由于从操作系统管理的内存分配,所以在分配和销毁时都要占用时间,因此用堆的效率非常低.但是堆的优点在于,编译器不必知道要从堆里分配多少存储空间,也不必知道存储的数据要在堆里停留多长的时间,因此,用堆保存数据时会得到更大的灵活性。事实上,面向对象的多态性,堆内存分配是必不可少的,因为多态变量所需的存储空间只有在运行时创建了对象之后才能确定.在C++中,要求创建一个对象时,只需用 new命令编制相关的代码即可。执行这些代码时,会在堆里自动进行数据的保存.当然,为达到这种灵活性,必然会付出一定的代价:在堆里分配存储空间时会花掉更长的时间!这也正是导致我们刚才所说的效率低的原因,看来列宁同志说的好,人的优点往往也是人的缺点,人的缺点往往也是人的优点(晕~).

      3 JVM中的堆和栈

      JVM是基于堆栈的虚拟机.JVM为每个新创建的线程都分配一个堆栈.也就是说,对于一个Java程序来说,它的运行就是通过对堆栈的操作来完成的。堆栈以帧为单位保存线程的状态。JVM对堆栈只进行两种操作:以帧为单位的压栈和出栈操作。

      我们知道,某个线程正在执行的方法称为此线程的当前方法.我们可能不知道,当前方法使用的帧称为当前帧。当线程激活一个Java方法,JVM就会在线程的 Java堆栈里新压入一个帧。这个帧自然成为了当前帧.在此方法执行期间,这个帧将用来保存参数,局部变量,中间计算过程和其他数据.这个帧在这里和编译原理中的活动纪录的概念是差不多的.

      从Java的这种分配机制来看,堆栈又可以这样理解:堆栈(Stack)是操作系统在建立某个进程时或者线程(在支持多线程的操作系统中是线程)为这个线程建立的存储区域,该区域具有先进后出的特性。

      每一个Java应用都唯一对应一个JVM实例,每一个实例唯一对应一个堆。应用程序在运行中所创建的所有类实例或数组都放在这个堆中,并由应用所有的线程共享.跟C/C++不同,Java中分配堆内存是自动初始化的。Java中所有对象的存储空间都是在堆中分配的,但是这个对象的引用却是在堆栈中分配,也就是说在建立一个对象时从两个地方都分配内存,在堆中分配的内存实际建立这个对象,而在堆栈中分配的内存只是一个指向这个堆对象的指针(引用)而已。

      Java 中的堆和栈

      Java把内存划分成两种:一种是栈内存,一种是堆内存。

      在函数中定义的一些基本类型的变量和对象的引用变量都在函数的栈内存中分配。

      当在一段代码块定义一个变量时,Java就在栈中为这个变量分配内存空间,当超过变量的作用域后,Java会自动释放掉为该变量所分配的内存空间,该内存空间可以立即被另作他用。

      堆内存用来存放由new创建的对象和数组。

      在堆中分配的内存,由Java虚拟机的自动垃圾回收器来管理。

      在堆中产生了一个数组或对象后,还可以在栈中定义一个特殊的变量,让栈中这个变量的取值等于数组或对象在堆内存中的首地址,栈中的这个变量就成了数组或对象的引用变量。

      引用变量就相当于是为数组或对象起的一个名称,以后就可以在程序中使用栈中的引用变量来访问堆中的数组或对象。

      具体的说:

      栈与堆都是Java用来在Ram中存放数据的地方。与C++不同,Java自动管理栈和堆,程序员不能直接地设置栈或堆。

      Java的堆是一个运行时数据区,类的(对象从中分配空间。这些对象通过new、newarray、anewarray和multianewarray等指令建立,它们不需要程序代码来显式的释放。堆是由垃圾回收来负责的,堆的优势是可以动态地分配内存大小,生存期也不必事先告诉编译器,因为它是在运行时动态分配内存的,Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是,由于要在运行时动态分配内存,存取速度较慢。

      栈的优势是,存取速度比堆要快,仅次于寄存器,栈数据可以共享。但缺点是,存在栈中的数据大小与生存期必须是确定的,缺乏灵活性。栈中主要存放一些基本类型的变量(,int, short, long, byte, float, double, boolean, char)和对象句柄。

      栈有一个很重要的特殊性,就是存在栈中的数据可以共享。假设我们同时定义:

     int a = 3;

      int b = 3;
    1
    2
    3
      编译器先处理int a = 3;首先它会在栈中创建一个变量为a的引用,然后查找栈中是否有3这个值,如果没找到,就将3存放进来,然后将a指向3。接着处理int b = 3;在创建完b的引用变量后,因为在栈中已经有3这个值,便将b直接指向3。这样,就出现了a与b同时均指向3的情况。这时,如果再令a=4;那么编译器会重新搜索栈中是否有4值,如果没有,则将4存放进来,并令a指向4;如果已经有了,则直接将a指向这个地址。因此a值的改变不会影响到b的值。要注意这种数据的共享与两个对象的引用同时指向一个对象的这种共享是不同的,因为这种情况a的修改并不会影响到b, 它是由编译器完成的,它有利于节省空间。而一个对象引用变量修改了这个对象的内部状态,会影响到另一个对象引用变量

    展开全文
  • 主要介绍了java内存溢出示例(溢出、溢出),需要的朋友可以参考下
  • 首先,在JVM的内存结构,比较常见的两个区域是内存和栈内存关于这两个概念的介绍一般如下: 1、是线程共享的内存区域,栈是线程独享的内存区域。 2、堆中主要存放对象实例,栈主要存放各种基本数据类型、...
  • java堆内存、栈内存、方法区

    千次阅读 2017-03-02 16:58:43
    JAVA的JVM的内存可分为3个区:(heap)、(stack)方法区(method) 区: 1.存储的全部是对象,每个对象都包含一个与之对应的class的信息。(class的目的是得到操作指令) 2.jvm只有一个区(heap)被所有线程共享...

    JAVA的JVM的内存可分为3个区:堆(heap)、栈(stack)和方法区(method)

    堆区:
    1.存储的全部是对象,每个对象都包含一个与之对应的class的信息。(class的目的是得到操作指令)
    2.jvm只有一个堆区(heap)被所有线程共享,堆中不存放基本类型和对象引用,只存放对象本身
    栈区:
    1.每个线程包含一个栈区,栈中只保存基础数据类型的对象和自定义对象的引用(不是对象),对象都存放在堆区中
    2.每个栈中的数据(原始类型和对象引用)都是私有的,其他栈不能访问。
    3.栈分为3个部分:基本类型变量区、执行环境上下文、操作指令区(存放操作指令)。
    方法区:
    1.又叫静态区,跟堆一样,被所有的线程共享。方法区包含所有的class和static变量。
    2.方法区中包含的都是在整个程序中永远唯一的元素,如class,static变量。

    请看两个例子

    例子1

    public classTest018 {
        // main我们
        public static void main(String[] args) {
            Listintl= newArrayList();
            intl.add(1);
            int i = 0;
            i++;
            int[] inta = new int[2];
            Personp = new Person();
            p.setName("张三");
            String[]stra= newString[2];
            Dogd = new Dog();
            p.setDog(d);
            Personq = new Person();
            Persont = p;
            List<Person>persons= newArrayList<Person>();
            persons.add(q);
            Personr = new Person();
            persons.add(r);
            for (i = 0; i < 5; i++) {
                for (int j = 0; j < 4; j++) {
                    System.out.println("i=" + i + " j=" + j);
                }
            }
            System.out.println("ttt");
        }
    }
    

    运行时每一步的图示:




    例子2

    为了更清楚地搞明白发生在运行时数据区里的黑幕,我们来准备2个小道具

    AppMain.java
     public  class AppMain                
    //运行时, jvm 把appmain的信息都放入方法区
    {
    public  static   void  main(String[] args)  //main 方法本身放入方法区。
    {
    Sample test1 = new  Sample(" 测试1 " );   //test1是引用,所以放到栈区里, Sample是自定义对象应该放到堆里面
    Sample test2 = new  Sample(" 测试2 " );
    test1.printName();
    test2.printName();
    }
    } 
    Sample.java
     public  class  Sample        //运行时, jvm 把appmain的信息都放入方法区
    {
    /** 范例名称 */
    private name;      //new Sample实例后, name 引用放入栈区里,  name对象放入堆里
    /** 构造方法 */
    public  Sample(String name)
    {
    this .name = name;
    }
    /** 输出 */
    public   void printName()   //print方法本身放入 方法区里。
    {
    System.out.println(name);
    }
    } 


    OK,让我们开始行动吧,出发指令就是:“java AppMain”,包包里带好我们的行动向导图,Let’s GO!



    系统收到了我们发出的指令,启动了一个Java虚拟机进程,这个进程首先从classpath中找到AppMain.class文件,读取这个文件中的二进制数据,然后把Appmain类的类信息存放到运行时数据区的方法区中。这一过程称为AppMain类的加载过程。
    接着,Java虚拟机定位到方法区中AppMain类的Main()方法的字节码,开始执行它的指令。这个main()方法的第一条语句就是:
    Sample test1=new Sample("测试1");
    语句很简单啦,就是让java虚拟机创建一个Sample实例,并且呢,使引用变量test1引用这个实例。貌似小case一桩哦,就让我们来跟踪一下Java虚拟机,看看它究竟是怎么来执行这个任务的:
    1、 Java虚拟机一看,不就是建立一个Sample实例吗,简单,于是就直奔方法区而去,先找到Sample类的类型信息再说。结果呢,嘿嘿,没找到@@,这会儿的方法区里还没有Sample类呢。可Java虚拟机也不是一根筋的笨蛋,于是,它发扬“自己动手,丰衣足食”的作风,立马加载了Sample类,把Sample类的类型信息存放在方法区里。
    2、 好啦,资料找到了,下面就开始干活啦。Java虚拟机做的第一件事情就是在堆区中为一个新的Sample实例分配内存, 这个Sample实例持有着指向方法区的Sample类的类型信息的引用。这里所说的引用,实际上指的是Sample类的类型信息在方法区中的内存地址,其实,就是有点类似于C语言里的指针啦~~,而这个地址呢,就存放了在Sample实例的数据区里。
    3、 在JAVA虚拟机进程中,每个线程都会拥有一个方法调用栈,用来跟踪线程运行中一系列的方法调用过程,栈中的每一个元素就被称为栈帧,每当线程调用一个方法的时候就会向方法栈压入一个新帧。这里的帧用来存储方法的参数、局部变量和运算过程中的临时数据。OK,原理讲完了,就让我们来继续我们的跟踪行动!位于“=”前的Test1是一个在main()方法中定义的变量,可见,它是一个局部变量,因此,它被会添加到了执行main()方法的主线程的JAVA方法调用栈中。而“=”将把这个test1变量指向堆区中的Sample实例,也就是说,它持有指向Sample实例的引用。
    OK,到这里为止呢,JAVA虚拟机就完成了这个简单语句的执行任务。参考我们的行动向导图,我们终于初步摸清了JAVA虚拟机的一点点底细了,COOL!
    接下来,JAVA虚拟机将继续执行后续指令,在堆区里继续创建另一个Sample实例,然后依次执行它们的printName()方法。当JAVA虚拟机执行test1.printName()方法时,JAVA虚拟机根据局部变量test1持有的引用,定位到堆区中的Sample实例,再根据Sample实例持有的引用,定位到方法去中Sample类的类型信息,从而获得printName()方法的字节码,接着执行printName()方法包含的指令。


    例子来自java学习手册,应用宝里面下载,它包含排序动画执行过程、java运行时堆栈内存结构图,J2SE基础、面试题、编程题以及二千多道选择题等。大部分代码都可以直接在手机上运行、调试,观察运行时变量状态以及变量值。j2se基础包含30章,260节内容,每一章内容都经过了精挑细选,深度加工,涵盖了java的所有内容。java学习手册代码部分采用了Eclipse的目录结构,代码全部高亮显示,多种主题供读者选择,文档中的图片均可以放大。文档样式、字体大小都可以控制.


    下载地址


    展开全文
  • 内存和栈内存的区别

    万次阅读 2019-03-14 00:03:46
    总结: 1 栈:为编译器自动分配和释放,如函数参数、局部变量、临时变量等等 2 堆:为成员分配和释放,由程序员自己申请、自己释放。否则发生内存泄露。...栈内存和堆内存的区别(一个笔试题的一部分)http://...
  • 在函数中定义的一些基本类型的变量对象的引用变量都在函数的栈内存中分配。 当在一段代码块定义一个变量时,Java就在栈中为这个变量分配内存空间,当超过变量的作用域后,Java会自动释放掉为该变量所分配的内存...
  • Java 内存管理(堆和)及 垃圾回收算法一.Jvm虚拟机内存简介1.1 Java运行时内存区1.2 线程私有的如下:1.3 线程共享的如下:二.Java 栈和堆2.1 堆栈的概念和特点2.2 与堆的异同2.3 举个例子另注:三.垃圾回收...
  • 堆内存完全由JVM负责分配释放,如果程序没有缺陷代码导致内存泄露,那么就不会遇到java.lang.OutOfMemoryError这个错误。 使用内存,就是为了能直接分配释放内存,提高效率。JDK5.0之后,代码中能直接操作...
  • java中内存分配策略及堆和栈的比较  1 内存分配策略   按照编译原理的观点,程序运行时的内存分配策略,分别是三种:a静态的,b式的,c式的.  a.静态存储分配是指在编译时就能确定每个数据目标在运行时刻的...
  • Java中栈内存和堆内存详解,非常容易理解
  • Java虚拟机:Java中堆和栈的详细区别

    万次阅读 2019-04-12 13:02:15
    在函数中定义的一些基本类型的变量对象的引用变量都在函数的栈内存中分配。 当在一段代码块定义一个变量时,Java就在栈中为这个变量分配内存空间,当超过变量的作用域后,Java会自动释放掉为该变量所分配的内存...
  • java中的基本数据类型引用数据类型以及它们的存储方式内存和栈内存
  • Java数组 在进入讲解主题“-栈内存与内存的区别”之前,先来讲解一下数组,所谓数组,就是若干个相同数据...在方法中定义的一些基本类型的变量对象的引用变量都在方法的栈内存中分配,当在一段代码块中定义一个变...
  • 分析Java内存分配的栈和堆以及常量池 一java虚拟机内存原型 寄存器我们在程序无法控制存放基本类型的数据和对象的引用但对象本身不存放在栈中而是存放在堆堆存放用new产生的数据静态域存放在对象中用static...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 298,431
精华内容 119,372
关键字:

java中堆内存和栈内存

java 订阅