Java内存管理知识整理

这里向大家简单介绍一下Java内存管理的概念和方法，Java内存管理就是对象的分配和释放问题。首先看一下分配和释放的概念，分配：内存的分配是由程序完成的，程序员需要通过关键字new为每个对象申请内存空间(基本类型除外)，所有的对象都在堆(Heap)中分配空间;而对象的释放是由垃圾回收机制决定和执行的。
　　Java内存管理总结

　　1.Java是如何管理内存的

　　Java内存管理就是对象的分配和释放问题。

　　分配：内存的分配是由程序完成的，程序员需要通过关键字new为每个对象申请内存空间(基本类型除外)，所有的对象都在堆(Heap)中分配空间。

　　释放：对象的释放是由垃圾回收机制决定和执行的，这样做确实简化了程序员的工作。但同时，它也加重了JVM的工作。这也是Java程序运行速度较慢的原因之一。因为，GC为了能够正确释放对象，GC必须监控每一个对象的运行状态，包括对象的申请、引用、被引用、赋值等，GC都需要进行监控。

　　2.什么叫Java的内存泄露

　　在Java内存管理中，内存泄漏就是存在一些被分配的对象，这些对象有下面两个特点，首先，这些对象是可达的，即在有向图中，存在通路可以与其相连(也就是说仍存在该内存对象的引用);其次，这些对象是无用的，即程序以后不会再使用这些对象。如果对象满足这两个条件，这些对象就可以判定为Java中的内存泄漏，这些对象不会被GC所回收，然而它却占用内存。

　　与C++内存泄露的区别：



　　在C++中，内存泄漏的范围更大一些。有些对象被分配了内存空间，然后却不可达，由于C++中没有GC，这些内存将永远收不回来。在Java中，这些不可达的对象都由GC负责回收，因此程序员不需要考虑这部分的内存泄露。

　　3.JVM的内存区域组成

　　Java把内存分两种：一种是栈内存，另一种是堆内存

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

　　2。堆内存用来存放由new创建的对象和数组以及对象的实例变量

　　在函数(代码块)中定义一个变量时，Java就在栈中为这个变量分配内存空间，当超过变量的作用域后，Java会自动释放掉为该变量所分配的内存空间;在堆中分配的内存由Java虚拟机的自动垃圾回收器来管理

3。栈的优缺点

　　堆的优势是可以动态分配内存大小，生存期也不必事先告诉编译器，因为它是在运行时动态分配内存的。缺点就是要在运行时动态分配内存，存取速度较慢;

　　栈的优势是，存取速度比堆要快，仅次于直接位于CPU中的寄存器。另外，栈数据可以共享。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。

　　4。Java内存管理中数据如何存储

　　a)基本数据类型

　　Java内存管理中的基本数据类型共有8种，即int,short,long,byte,float,double,boolean,char(注意，并没有string的基本类型)。这种类型的定义是通过诸如inta=3;longb=255L;的形式来定义的。如inta=3;这里的a是一个指向int类型的引用，指向3这个字面值。这些字面值的数据，由于大小可知，生存期可知(这些字面值定义在某个程序块里面，程序块退出后，字段值就消失了)，出于追求速度的原因，就存在于栈中。

　　另外，栈有一个很重要的特殊性，就是存在栈中的数据可以共享。

　　比如：我们同时定义：

　　inta=3;

　　intb=3;

　　编译器先处理inta=3;首先它会在栈中创建一个变量为a的引用，然后查找有没有字面值为3的地址，没找到，就开辟一个存放3这个字面值的地址，然后将a指向3的地址。接着处理intb=3;在创建完b这个引用变量后，由于在栈中已经有3这个字面值，便将b直接指向3的地址。这样，就出现了a与b同时均指向3的情况。

　　定义完a与b的值后，再令a=4;那么，b不会等于4，还是等于3。在编译器内部，遇到时，它就会重新搜索栈中是否有4的字面值，如果没有，重新开辟地址存放4的值;如果已经有了，则直接将a指向这个地址。因此a值的改变不会影响到b的值。

　　b)对象

　　在Java内存管理中，创建一个对象包括对象的声明和实例化两步，下面用一个例题来说明对象的内存模型。

　　假设有类Rectangle定义如下：

　　Java代码

以下是代码片段： classRectangle{ doublewidth,height； Rectangle(doublew,doubleh){ 　wwidth=w； hheight=h； } } classRectangle{ doublewidth,height； Rectangle(doublew,doubleh){ 　wwidth=w； hheight=h； } }

　　(1)明对象时的内存模型

　　用Rectanglerect;声明一个对象rect时，将在栈内存为对象的引用变量rect分配内存空间，但Rectangle的值为空，称rect是一个空对象。空对象不能使用，因为它还没有引用任何“实体”。

　　(2)对象实例化时的内存模型

　　当执行rect=newRectangle(3,5);时，会做两件事：

　　在堆内存中为类的成员变量width,height分配内存，并将其初始化为各数据类型的默认值;接着进行显式初始化(类定义时的初始化值);最后调用构造方法，为成员变量赋值。

　　返回堆内存中对象的引用(相当于首地址)给引用变量rect,以后就可以通过rect来引用堆内存中的对象了。

　　c)创建多个不同的对象实例

　　一个类通过使用new运算符可以创建多个不同的对象实例，这些对象实例将在堆中被分配不同的内存空间，改变其中一个对象的状态不会影响其他对象的状态。例如：

　　Java代码

以下是代码片段： Rectangler1=newRectangle(3,5)； Rectangler2=newRectangle(4,6)； Rectangler1=newRectangle(3,5)； Rectangler2=newRectangle(4,6)；

 
　　此时，将在堆内存中分别为两个对象的成员变量width、height分配内存空间，两个对象在堆内存中占据的空间是互不相同的。如果有：

　　Java代码

以下是代码片段： Rectangler1=newRectangle(3,5)； Rectangler2=r1； Rectangler1=newRectangle(3,5)； Rectangler2=r1；

　　则在堆内存中只创建了一个对象实例，在栈内存中创建了两个对象引用，两个对象引用同时指向一个对象实例。

d)包装类
　　Java内存管理中数据的基本型别都有对应的包装类：如int对应Integer类，double对应Double类等，基本类型的定义都是直接在栈中，如果用包装类来创建对象，就和普通对象一样了。例如：inti=0;i直接存储在栈中。Integeri(i此时是对象)=newInteger(5);这样，i对象数据存储在堆中，i的引用存储在栈中，通过栈中的引用来操作对象。

　　e)String

　　String是一个特殊的包装类数据。可以用用以下两种方式创建：

以下是代码片段： 1.Stringstr=newString("abc")； 2.Stringstr="abc"；

　　第一种创建方式，和普通对象的的创建过程一样;

　　第二种创建方式，Java内部将此语句转化为以下几个步骤：

　　(1)先定义一个名为str的对String类的对象引用变量：Stringstr;

　　(2)在栈中查找有没有存放值为“abc”的地址，如果没有，则开辟一个存放字面值为“abc”的地址，接着创建一个新的String类的对象o，并将o的字符串值指向这个地址，而且在栈中这个地址旁边记下这个引用的对象o。如果已经有了值为“abc”的地址，则查找对象o，并返回o的地址。

　　(3)将str指向对象o的地址。

　　值得注意的是，一般String类中字符串值都是直接存值的。但像Stringstr="abc";这种场合下，其字符串值却是保存了一个指向存在栈中数据的引用。

　　为了更好地说明这个问题，我们可以通过以下的几个代码进行验证。

　　Java代码

以下是代码片段： Stringstr1=“abc”； Stringstr2=“abc”； System.out.println(s1==s2)；//true Stringstr1=“abc”； Stringstr2=“abc”； System.out.println(s1==s2)；//true

　　注意，这里并不用str1.equals(str2);的方式，因为这将比较两个字符串的值是否相等。==号，根据JDK的说明，只有在两个引用都指向了同一个对象时才返回真值。而我们在这里要看的是，str1与str2是否都指向了同一个对象。

　　我们再接着看以下的代码。

　　Java代码

以下是代码片段： Stringstr1=newString(“abc”)； Stringstr2=“abc”； System.out.println(str1==str2)；//false Stringstr1=newString(“abc”)； Stringstr2=“abc”； System.out.println(str1==str2)；//false

  
　　创建了两个引用。创建了两个对象。两个引用分别指向不同的两个对象。

　　以上两段代码说明，只要是用new()来新建对象的，都会在堆中创建，而且其字符串是单独存值的，即使与栈中的数据相同，也不会与栈中的数据共享。

f)数组
　　当定义一个数组，intx[];或int[]x;时，在栈内存中创建一个数组引用，通过该引用(即数组名)来引用数组。x=newint[3];将在堆内存中分配3个保存int型数据的空间，堆内存的首地址放到栈内存中，每个数组元素被初始化为0。

　　g)静态变量

　　用static的修饰的变量和方法，实际上是指定了这些变量和方法在内存中的“固定位置”-staticstorage，可以理解为所有实例对象共有的内存空间。static变量有点类似于C中的全局变量的概念;静态表示的是内存的共享，就是它的每一个实例都指向同一个内存地址。把static拿来，就是告诉JVM它是静态的，它的引用(含间接引用)都是指向同一个位置，在那个地方，你把它改了，它就不会变成原样，你把它清理了，它就不会回来了。

　　那静态变量与方法是在什么时候初始化的呢？对于两种不同的类属性，static属性与instance属性，初始化的时机是不同的。instance属性在创建实例的时候初始化，static属性在类加载，也就是第一次用到这个类的时候初始化，对于后来的实例的创建，不再次进行初始化。

　　我们常可看到类似以下的例子来说明这个问题：

　　Java代码

以下是代码片段： classStudent{ staticintnumberOfStudents=0; Student() { numberOfStudents++; } } classStudent{ staticintnumberOfStudents=0; Student() { numberOfStudents++; } }

　　每一次创建一个新的Student实例时,成员numberOfStudents都会不断的递增,并且所有的Student实例都访问同一个numberOfStudents变量,实际上intnumberOfStudents变量在内存中只存储在一个位置上。

另外转载http://liu1227787871.blog.163.com/blog/static/205363197201263103320466/的的总结

一、内存管理原理：

在java中，有java程序、虚拟机、操作系统三个层次，其中java程序与虚拟机交互，而虚拟机与操作系统间交互！这就保证了java程序的平台无关性！下面我们从程序运行前，程序运行中、程序运行内存溢出三个阶段来说一下内存管理原理！

1、程序运行前：JVM向操作系统请求一定的内存空间，称为初始内存空间！程序执行过程中所需的内存都是由java虚拟机从这片内存空间中划分的。

2、程序运行中：java程序一直向java虚拟机申请内存，当程序所需要的内存空间超出初始内存空间时，java虚拟机会再次向操作系统申请更多的内存供程序使用！

3、内存溢出：程序接着运行，当java虚拟机已申请的内存达到了规定的最大内存空间，但程序还需要更多的内存，这时会出现内存溢出的错误！

至此可以看出，Java 程序所使用的内存是由 Java 虚拟机进行管理、分配的。Java 虚拟机规定了 Java 程序的初始内存空间和最大内存空间，开发者只需要关心 Java 虚拟机是如何管理内存空间的，而不用关心某一种操作系统是如何管理内存的。  

 

二、 RUNTIME 类的使用：

Java 给我们提供了Runtime 类得到JVM 内存的信息

方法名称	参数	作用	返回值
getRuntime	无	获取Runtime 对象	Runtime 对象
totalMemory	无	获取JVM 分配给程序的内存数量	long：内存数量
freeMemory	无	获取当前可用的内存数量	long：内存数量
maxMemory	无	获取JVM 可以申请到的最大内存数量	long：内存数量

   

三、内存空间逻辑划分：

JVM 会把申请的内存从逻辑上划分为三个区域，即：方法区、堆与栈。 

方法区：方法区默认最大容量为64M，Java虚拟机会将加载的java类存入方法区，保存类的结构（属性与方法），类静态成员等内容。

堆：默认最大容量为64M，堆存放对象持有的数据，同时保持对原类的引用。可以简单的理解为对象属性的值保存在堆中，对象调用的方法保存在方法区。

栈：栈默认最大容量为1M，在程序运行时，每当遇到方法调用时，Java虚拟机就会在栈中划分一块内存称为栈帧（Stack frame），栈帧中的内存供局部变量（包括基本类型与引用类型）使用，当方法调用结束后，Java虚拟机会收回此栈帧占用的内存。 

四、java数据类型



1、基本数据类型：没封装指针的变量。
声明此类型变量，只会在栈中分配一块内存空间。

2、引用类型：就是底层封装指针的数据类型。

他们在内存中分配两块空间，第一块内存分配在栈中，只存放别的内存地址，不存放具体数值，我们也把它叫指针类型的变量，第二块内存分配在堆中，存放的是具体数值，如对象属性值等。

3、下面我们从一个例子来看一看：

public class Student { 
  String stuId; 
  String stuName; 
  int stuAge; 
} 

public class TestStudent { 
  public static void main(String[] args) { 
    Student zhouxingxing = new Student(); 
    String name = new String("旺旺");  
    int a = 10; 
    char b = 'm'; 
    zhouxingxing.stuId = "9527"; 
    zhouxingxing.stuName = "周星星"; 
    zhouxingxing.stuAge = 25; 
  } 
}

（1）类当然是存放在方法区里面的。

（2）Student zhouxingxing = new Student(); 
这行代码就创建了两块内存空间，第一个在栈中，名字叫zhouxingxing，它就相当于指针类型的变量，我们看到它并不存放学生的姓名、年龄等具体的数值，而是存放堆中第二块内存的地址，第二块才存放具体的数值，如学生的编号、姓名、年龄等信息。

（3）int a = 10; 
这是 基本数据类型 变量，具体的值就存放在栈中，并没有只指针的概念！

下图就是本例的内存布置图：



此外我们还要知道Student zhouxingxing = new Student(); 包括了声明和创建，即：Student zhouxingxing;和zhouxingxing = new Student();其中声明只是在栈中声明一个空间，但还没有具体的值，声明后的情况如下图所示：



创建后的情况如下图所示：



（4）引用类型中的数组也封装了指针，即便是基本数据类型的数组也封装了指针，数组也是引用类型。比如代码int[] arr = new int[]{23，2，4，3，1};如下图所示：



 
 五、java值传参与引用参数

（1）参数根据调用后的效果不同，即是否改变参数的原始数值，又可以分为两种:按值传递的参数与按引用传递的参数。

按值传递的参数原始数值不改变，按引用传递的参数原始数值改变！这是为什么呢？其实相当简单：
我们知道基本数据类型的变量存放在栈里面，变量名处存放的就是变量的值，那么当基本数据类型的变量作为参数时，传递的就是这个值，只是把变量的值传递了过去，不管对这个值如何操作，都不会改变变量的原始值。而对引用数据类型的变量来说，变量名处存放的地址，所以引用数据类型的变量作为传参时，传递的实际上是地址，对地址处的内容进行操作，当然会改变变量的值了！

（2）特例：string

public class TestString { 
  public static void main(String[] args) { 
     
    String name = "wangwang"; 
    TestString testString = new TestString(); 
     
    System.out.println("方法调用前：" + name); 
    testString.change(name); 
    System.out.println("方法调用后：" + name); 
  } 
   
  void change(String str) { 
    str = "旺旺老师"; 
    System.out.println("方法体内修改值后：" + str); 
  } 

} 

结果：

方法调用前：wangwang 
方法体内修改值后：旺旺老师 
方法调用后：wangwang 

分析：
上例中，虽然参数String 是引用数据类型，但其值没有发生改变，这是因为String 类
是final 的，它是定长，我们看初始情况，即String name = "wangwang";这行代码运行
完，如下图：



 当调用方法时testString.change(name)，内存变化为：



在方法体内，参数str赋予一个新值，str = "旺旺老师"。因为String是定长，系统就会在堆中分配一块新的内存空间37DF，这样str指向了新的内存空间37DF，而name还是指向36DF， 37DF的改变对它已没影响：



最后，方法调用结束，str与37DF的内存空间消亡。Name的值依然为wangwang,并没有改变。
所以String虽然是引用类型参数，但值依然不变：



 
 （3）无法交换的例子：

public class TestChange { 
  void change(Student stu1, Student stu2) { 
    stu1.stuAge ++; 
    stu2.stuAge ++; 
    Student stu = stu1; 
    stu1 = stu2; 
    stu2 = stu; 
  } 
   
  public static void main(String[] args) { 
     
    Student furong = new Student(); 
    furong.stuName = "芙蓉姐姐"; 
    furong.stuAge = 30; 
     
    Student fengjie = new Student(); 
    fengjie.stuName = "凤姐"; 
    fengjie.stuAge = 26; 
     
    TestChange testChange = new TestChange(); 
    testChange.change(furong, fengjie); 
     
    System.out.println(furong.stuName); 
    System.out.println(furong.stuAge); 
     
    System.out.println(fengjie.stuName); 
    System.out.println(fengjie.stuAge); 
  } 
 
} 

运行结果：
芙蓉姐姐 
31 
凤姐 
27 

分析：