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虚拟机的自动垃圾回收器来管理

 

堆和栈的优缺点
        堆的优势是可以动态分配内存大小，生存期也不必事先告诉编译器，因为它是在运行时动态分配内存的。缺点就是要在运行时动态分配内存，存取速度较慢；
栈的优势是，存取速度比堆要快，仅次于直接位于CPU中的寄存器。另外，栈数据可以共享。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。

4.    Java中数据在内存中是如何存储的

a)    基本数据类型

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

         另外，栈有一个很重要的特殊性，就是存在栈中的数据可以共享。
         比如：我们同时定义：
　　        int a = 3；
              int b=3；
        编译器先处理int a = 3；首先它会在栈中创建一个变量为a的引用，然后查找有没有字面值为3的地址，没找到，就开辟一个存放3这个字面值的地址，然后将a指向3的地址。接着处理int b = 3；在创建完b这个引用变量后，由于在栈中已经有3这个字面值，便将b直接指向3的地址。这样，就出现了a与b同时均指向3的情况。
       定义完a与b的值后，再令a = 4；那么，b不会等于4，还是等于3。在编译器内部，遇到时，它就会重新搜索栈中是否有4的字面值，如果没有，重新开辟地址存放4的值；如果已经有了，则直接将a指向这个地址。因此a值的改变不会影响到b的值。

b)    对象

        在Java中，创建一个对象包括对象的声明和实例化两步，下面用一个例题来说明对象的内存模型。
　　  假设有类Rectangle定义如下：

 

Java代码

1. class Rectangle{   
2.   
3. 　　        double width,height；   
4.   
5. 　　        Rectangle(double w,double h){   
6. 　                   width=w；   
7.                       height=h；   
8.               }   
9. }  

class Rectangle{　　        double width,height；　　        Rectangle(double w,double h){　                   width=w；                      height=h；              }}

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

　　(2)对象实例化时的内存模型
　　当执行rect=new Rectangle(3,5)；时，会做两件事：
　　在堆内存中为类的成员变量width,height分配内存，并将其初始化为各数据类型的默认值；接着进行显式初始化（类定义时的初始化值）；最后调用构造方法，为成员变量赋值。
      返回堆内存中对象的引用（相当于首地址）给引用变量rect,以后就可以通过rect来引用堆内存中的对象了。

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

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

Java代码

1. Rectangle r1=new Rectangle(3,5)；   
2. Rectangle r2=new Rectangle(4,6)；  

Rectangle r1=new Rectangle(3,5)；Rectangle r2=new Rectangle(4,6)；

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

Java代码

1. Rectangle r1=new Rectangle(3,5)；   
2. Rectangle r2=r1；  

Rectangle r1=new Rectangle(3,5)；Rectangle r2=r1；

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

 

d)    包装类

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

 

e)    String

         String是一个特殊的包装类数据。可以用用以下两种方式创建：
         1.   String str = new String("abc")；
         2.   String str = "abc"；

         第一种创建方式，和普通对象的的创建过程一样；
         第二种创建方式，Java内部将此语句转化为以下几个步骤：
　      (1) 先定义一个名为str的对String类的对象引用变量：String str；
　      (2) 在栈中查找有没有存放值为“abc”的地址，如果没有，则开辟一个存放字面值为“abc”的地址，接着创建一个新的String类的对象o，并将o的字符串值指向这个地址，而且在栈中这个地址旁边记下这个引用的对象o。如果已经有了值为“abc”的地址，则查找对象o，并返回o的地址。
      　(3) 将str指向对象o的地址。

         值得注意的是，一般String类中字符串值都是直接存值的。但像String str = "abc"；这种场合下，其字符串值却是保存了一个指向存在栈中数据的引用。
         为了更好地说明这个问题，我们可以通过以下的几个代码进行验证。

 

Java代码

1. String str1=“abc”；   
2. String str2=“abc”；   
3. System.out.println(s1==s2)；//true  

String str1=“abc”；String str2=“abc”；System.out.println(s1==s2)；//true

 

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

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

Java代码

1. Stringstr1=new String(“abc”)；   
2. Stringstr2=“abc”；   
3. System.out.println(str1==str2)；//false  

Stringstr1=new String(“abc”)；Stringstr2=“abc”；System.out.println(str1==str2)；//false

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

 

f)    数组

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

 

g)    静态变量

         用static的修饰的变量和方法，实际上是指定了这些变量和方法在内存中的“固定位置”－static storage，可以理解为所有实例对象共有的内存空间。static变量有点类似于C中的全局变量的概念；静态表示的是内存的共享，就是它的每一个实例都指向同一个内存地址。把static拿来，就是告诉JVM它是静态的，它的引用（含间接引用）都是指向同一个位置，在那个地方，你把它改了，它就不会变成原样，你把它清理了，它就不会回来了。
         那静态变量与方法是在什么时候初始化的呢？对于两种不同的类属性，static属性与instance属性，初始化的时机是不同的。instance属性在创建实例的时候初始化，static属性在类加载，也就是第一次用到这个类的时候初始化，对于后来的实例的创建，不再次进行初始化。
         我们常可看到类似以下的例子来说明这个问题：

Java代码

1. class Student{   
2.         static int numberOfStudents=0;   
3.         Student()   
4.         {   
5.                  numberOfStudents++;   
6.         }   
7. }  

class Student{        static int numberOfStudents=0;        Student()        {                 numberOfStudents++;        }}

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

 

5. Java的内存管理实例

         Java程序的多个部分(方法，变量，对象)驻留在内存中以下两个位置：即堆和栈，现在我们只关心3类事物：实例变量，局部变量和对象：

• 实例变量和对象驻留在堆上
• 局部变量驻留在栈上

       让我们查看一个java程序，看看他的各部分如何创建并且映射到栈和堆中：

Java代码

1. public class Dog {   
2.     Collar c;   
3.     String name;   
4.        
5.     //1. main()方法位于栈上   
6.     public static void main(String[] args) {   
7.         //2. 在栈上创建引用变量d,但Dog对象尚未存在   
8.         Dog d;   
9.         //3. 创建新的Dog对象，并将其赋予d引用变量   
10.         d = new Dog();   
11.         //4. 将引用变量的一个副本传递给go()方法   
12.         d.go(d);   
13.     }   
14.     //5. 将go()方法置于栈上，并将dog参数作为局部变量   
15.     void go(Dog dog){   
16.         //6. 在堆上创建新的Collar对象，并将其赋予Dog的实例变量   
17.         c =new Collar();   
18.     }   
19.     //7.将setName()添加到栈上，并将dogName参数作为其局部变量   
20.     void setName(String dogName){   
21.         //8. name的实例对象也引用String对象   
22.         name=dogName;   
23.     }   
24.     //9. 程序执行完成后，setName()将会完成并从栈中清除，此时，局部变量dogName也会消失，尽管它所引用的String仍在堆上   
25. }   
26.    

public class Dog {Collar c;String name;//1. main()方法位于栈上public static void main(String[] args) {//2. 在栈上创建引用变量d,但Dog对象尚未存在Dog d;//3. 创建新的Dog对象，并将其赋予d引用变量d = new Dog();//4. 将引用变量的一个副本传递给go()方法d.go(d);}//5. 将go()方法置于栈上，并将dog参数作为局部变量void go(Dog dog){//6. 在堆上创建新的Collar对象，并将其赋予Dog的实例变量c =new Collar();}//7.将setName()添加到栈上，并将dogName参数作为其局部变量void setName(String dogName){//8. name的实例对象也引用String对象name=dogName;}//9. 程序执行完成后，setName()将会完成并从栈中清除，此时，局部变量dogName也会消失，尽管它所引用的String仍在堆上} 

6. 垃圾回收机制：

（问题一：什么叫垃圾回收机制？） 垃圾回收是一种动态存储管理技术，它自动地释放不再被程序引用的对象，按照特定的垃圾收集算法来实现资源自动回收的功能。当一个对象不再被引用的时候，内存回收它占领的空间，以便空间被后来的新对象使用，以免造成内存泄露。
（问题二：java的垃圾回收有什么特点？） JAVA语言不允许程序员直接控制内存空间的使用。内存空间的分配和回收都是由JRE负责在后台自动进行的，尤其是无用内存空间的回收操作(garbagecollection,也称垃圾回收)，只能由运行环境提供的一个超级线程进行监测和控制。
（问题三：垃圾回收器什么时候会运行？） 一般是在CPU空闲或空间不足时自动进行垃圾回收，而程序员无法精确控制垃圾回收的时机和顺序等。
（问题四：什么样的对象符合垃圾回收条件？） 当没有任何获得线程能访问一个对象时，该对象就符合垃圾回收条件。
（问题五：垃圾回收器是怎样工作的？） 垃圾回收器如发现一个对象不能被任何活线程访问时，他将认为该对象符合删除条件，就将其加入回收队列，但不是立即销毁对象，何时销毁并释放内存是无法预知的。垃圾回收不能强制执行，然而Java提供了一些方法（如：System.gc()方法），允许你请求JVM执行垃圾回收，而不是要求，虚拟机会尽其所能满足请求，但是不能保证JVM从内存中删除所有不用的对象。
（问题六：一个java程序能够耗尽内存吗？） 可以。垃圾收集系统尝试在对象不被使用时把他们从内存中删除。然而，如果保持太多活的对象，系统则可能会耗尽内存。垃圾回收器不能保证有足够的内存，只能保证可用内存尽可能的得到高效的管理。
（问题七：如何显示的使对象符合垃圾回收条件？）
         （1） 空引用 ：当对象没有对他可到达引用时，他就符合垃圾回收的条件。也就是说如果没有对他的引用，删除对象的引用就可以达到目的，因此我们可以把引用变量设置为null，来符合垃圾回收的条件。

Java代码

1. StringBuffer sb = new StringBuffer("hello");   
2. System.out.println(sb);   
3. sb=null;  

StringBuffer sb = new StringBuffer("hello");System.out.println(sb);sb=null;

        （2） 重新为引用变量赋值：可以通过设置引用变量引用另一个对象来解除该引用变量与一个对象间的引用关系。

Java代码

1. StringBuffer sb1 = new StringBuffer("hello");   
2. StringBuffer sb2 = new StringBuffer("goodbye");   
3. System.out.println(sb1);   
4. sb1=sb2;//此时"hello"符合回收条件  

StringBuffer sb1 = new StringBuffer("hello");StringBuffer sb2 = new StringBuffer("goodbye");System.out.println(sb1);sb1=sb2;//此时"hello"符合回收条件

        （3） 方法内创建的对象：所创建的局部变量仅在该方法的作用期间内存在。一旦该方法返回，在这个方法内创建的对象就符合垃圾收集条件。有一种明显的例外情况，就是方法的返回对象。

Java代码

1. public static void main(String[] args) {   
2.         Date d = getDate();   
3.         System.out.println("d = " + d);   
4. }   
5. private static Date getDate() {   
6.         Date d2 = new Date();   
7.         StringBuffer now = new StringBuffer(d2.toString());   
8.         System.out.println(now);   
9.         return d2;   
10. }  

public static void main(String[] args) {        Date d = getDate();        System.out.println("d = " + d);}private static Date getDate() {        Date d2 = new Date();        StringBuffer now = new StringBuffer(d2.toString());        System.out.println(now);        return d2;}

 

         （4） 隔离引用：这种情况中，被回收的对象仍具有引用，这种情况称作隔离岛。若存在这两个实例，他们互相引用，并且这两个对象的所有其他引用都删除，其他任何线程无法访问这两个对象中的任意一个。也可以符合垃圾回收条件。

Java代码

1. public class Island {   
2.         Island i;   
3.         public static void main(String[] args) {   
4.                 Island i2 = new Island();   
5.                 Island i3 = new Island();   
6.                 Island i4 = new Island();   
7.                 i2.i=i3;   
8.                 i3.i=i4;   
9.                 i4.i=i2;   
10.                 i2=null;   
11.                 i3=null;   
12.                 i4=null;   
13.         }   
14. }  

public class Island {        Island i;        public static void main(String[] args) {                Island i2 = new Island();                Island i3 = new Island();                Island i4 = new Island();                i2.i=i3;                i3.i=i4;                i4.i=i2;                i2=null;                i3=null;                i4=null;        }}

 

（问题八：垃圾收集前进行清理------finalize()方法） java提供了一种机制，使你能够在对象刚要被垃圾回收之前运行一些代码。这段代码位于名为finalize()的方法内，所有类从Object类继承这个方法。由于不能保证垃圾回收器会删除某个对象。因此放在finalize()中的代码无法保证运行。因此建议不要重写finalize();