精华内容
下载资源
问答
  • java的内存管理

    2012-09-08 22:27:54
    java的内存管理 1. java是如何管理内存的  Java的内存管理就是对象的分配和释放问题。(两部分) 分配 :内存的分配是由程序完成的,程序员需要通过关键字new 为每个对象申请内存空间 (基本...

    java的内存管理



    1. java是如何管理内存的

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

    分配 :内存的分配是由程序完成的,程序员需要通过关键字new 为每个对象申请内存空间 (基本类型除外),所有的对象都在堆 (Heap)中分配空间。
    释放:对象的释放是由垃圾回收机制决定和执行的,这样做确实简化了程序员的工作。但同时,它也加重了JVM的工作。因为,GC为了能够正确释放对象,GC必须监控每一个对象的运行状态,包括对象的申请、引用、被引用、赋值等,GC都需要进行监控。

    2. 什么叫java的内存泄露

         在Java中,内存泄漏就是存在一些被分配的对象,华夏名网怎么样这些对象有下面两个特点,首先,这些对象是可达的,即在有向图中,存在通路可以与其相连(也就是说仍存在该内存对象的引用);其次,这些对象是无用的,即程序以后不会再使用这些对象。如果对象满足这两个条件,这些对象就可以判定为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定义如下:
    public class Rectangle {
     double width;
     double height;
    public Rectangle(double w,double h)

     {
     w = width;
     h = height;
     }
    }


    (1)声明对象时的内存模型
     用Rectangle rect;声明一个对象rect时,将在栈内存为对象的引用变量rect分配内存空间,但Rectangle的值为空,称rect是一个空对象。空对象不能使用,因为它还没有引用任何"实体"。
    (2)对象实例化时的内存模型
     当执行rect=new Rectangle(3,5);时,会做两件事: 在堆内存中为类的成员变量width,height分配内存,并将其初始化为各数据类型的默认值;接着进行显式初始化(类定义时的初始化值);最后调用构造方法,为成员变量赋值。  返回堆内存中对象的引用(相当于首地址)给引用变量rect,以后就可以通过rect来引用堆内存中的对象了。


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

       一个类通过使用new运算符可以创建多个不同的对象实例,这些对象实例将在堆中被分配不同的内存空间,改变其中一个对象的状态不会影响其他对象的状态。例如:
    Rectangle r1= new Rectangle(3,5);
    Rectangle r2= new Rectangle(4,6);
     此时,将在堆内存中分别为两个对象的成员变量width、height分配内存空间,两个对象在堆内存中占据的空间是互不相同的。如果有:
    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是一个特殊的包装类数据。可以用用以下两种方式创建:String str = new String("abc");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";这种
    合下,其字符串值却是保存了一个指向存在栈中数据的引用。
    为了更好地说明这个问题,我们可以通过以下的几个代码进行验证。
    String str1="abc";
    String str2="abc";
    System.out.println(s1==s2);//true
    注意,这里并不用str1.equals(str2);的方式,因为这将比较两个字符串的值是否相等。==号,根据JDK的说明,只有在两个引用都指向了同一个对象时才返回真值。而我们在这里要看的是,str1与str2是否都指向了同一个对象。
    我们再接着看以下的代码。
    String str1= new String("abc");
    String str2="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属性在类加载,也就是第一次用到这个类的时候初始化,对于后来的实例的创建,不再次进行初始化。         我们常可看到类似以下的例子来说明这个问题:
    class Student{
    static int numberOfStudents=0;
    Student()
    {
    numberOfStudents++;
    }
    }
    每一次创建一个新的Student实例时,成员numberOfStudents都会不断的递增,并且所有的Student实例都访问同一个numberOfStudents变量,实际上int numberOfStudents变量在内存中只存储在一个位置上。

    5. Java的内存管理实例

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


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


    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,来符合垃圾回收的条件。
    StringBuffer sb = new StringBuffer("hello");
    System.out.println(sb);
    sb=null;
    (2)重新为引用变量赋值:可以通过设置引用变量引用另一个对象来解除该引用变量与一个对象间的引用关系。
    StringBuffer sb1 = new StringBuffer("hello");
    StringBuffer sb2 = new StringBuffer("goodbye");
    System.out.println(sb1);
    sb1=sb2;//此时"hello"符合回收条件 
    (3)方法内创建的对象:所创建的局部变量仅在该方法的作用期间内存在。一旦该方法返回,在这个方法内创建的对象就符合垃圾收集条件。有一种明显的例外情况,就是方法的返回对象。
    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)隔离引用:这种情况中,被回收的对象仍具有引用,这种情况称作隔离岛。若存在这两个实例,他们互相引用,并且这两个对象的所有其他引用都删除,其他任何线程无法访问这两个对象中的任意一个。也可以符合垃圾回收条件。
    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();


    7. final问题:
         final使得被修饰的变量"不变",但是由于对象型变量的本质是"引用",使得"不变"也有了两种含义:引用本身的不变?,和引用指向的对象不变。?         
    引用本身的不变:
    final StringBuffer a=new StringBuffer("immutable");
    final StringBuffer b=new StringBuffer("not immutable");
    a=b;//编译期错误
    引用指向的对象不变:
    final StringBuffer a=new StringBuffer("immutable");
    a.append(" broken!"); //编译通过
    可见,final只对引用的"值"(也即它所指向的那个对象的内存地址)有效,它迫使引用只能指向初始指向的那个对象,改变它的指向会导致编译期错误。至于它所指向的对象的变化,final是不负责的。这很类似==操作符:==操作符只负责引用的"值"相等,至于这个地址所指向的对象内容是否相等,==操作符是不管的。在举一个例子:

    public class Name {
    private String firstname;
    private String lastname;
    public String getFirstname() {
    return firstname;
    }
    public void setFirstname(String firstname) {
    this.firstname = firstname;
    }
    public String getLastname() {
    return lastname;
    }
    public void setLastname(String lastname) {
    this.lastname = lastname;
    }
    }
     
    编写测试方法:
    public static void main(String[] args) {
    final Name name = new Name();
    name.setFirstname("JIM");
    name.setLastname("Green");
    System.out.println(name.getFirstname()+" "+name.getLastname());
    }
     
        理解final问题有很重要的含义。许多程序漏洞都基于此----final只能保证引用永远指向固定对象,不能保证那个对象的状态不变。在多线程的操作中,一个对象会被多个线程共享或修改,一个线程对对象无意识的修改可能会导致另一个使用此对象的线程崩溃。一个错误的解决方法就是在此对象新建的时候把它声明为final,意图使得它"永远不变"。其实那是徒劳的。        Final还有一个值得注意的地方:         先看以下示例程序:
    class Something {
    final int i;
    public void doSomething() {
    System.out.println("i = " + i);
    }
    }
        对于类变量,Java虚拟机会自动进行初始化。如果给出了初始值,则初始化为该初始值。如果没有给出,则把它初始化为该类型变量的默认初始值。但是对于用final修饰的类变量,虚拟机不会为其赋予初值,必须在constructor (构造器)结束之前被赋予一个明确的值。可以修改为"final int i = 0;"。
     
    8.    如何把程序写得更健壮:
        1、尽早释放无用对象的引用。好的办法是使用临时变量的时候,让引用变量在退出活动域后,自动设置为null,暗示垃圾收集器来收集该对象,防止发生内存泄露。对于仍然有指针指向的实例,jvm就不会回收该资源,因为垃圾回收会将值为null的对象作为垃圾,提高GC回收机制效率;
        2、定义字符串应该尽量使用 String str="hello"; 的形式,避免使用String str = new String("hello"); 的形式。因为要使用内容相同的字符串,不必每次都new一个String。例如我们要在构造器中对一个名叫s的String引用变量进行初始化,把它设置为初始值,应当这样做:
    public class Demo {
    private String s;
    public Demo() {
    s = "Initial Value";
    }
    }
     
    public class Demo {
    private String s;
    ...
    public Demo {
    s = "Initial Value";
    }
    ...
    }
     而非
    s = new String("Initial Value"); 
    s = new String("Initial Value");
         后者每次都会调用构造器,生成新对象,性能低下且内存开销大,并且没有意义,因为String对象不可改变,所以对于内容相同的字符串,只要一个String对象来表示就可以了。也就说,多次调用上面的构造器创建多个对象,他们的String类型属性s都指向同一个对象。   

    3、我们的程序里不可避免大量使用字符串处理,避免使用String,应大量使用StringBuffer ,因为String被设计成不可变(immutable)类,所以它的所有对象都是不可变对象,请看下列代码;
    String s = "Hello";  
    s = s + " world!"; 
    String s = "Hello";
    s = s + " world!";
           在这段代码中,s原先指向一个String对象,内容是 "Hello",然后我们对s进行了+操作,那么s所指向的那个对象是否发生了改变呢?答案是没有。这时,s不指向原来那个对象了,而指向了另一个 String对象,内容为"Hello world!",原来那个对象还存在于内存之中,只是s这个引用变量不再指向它了。         通过上面的说明,我们很容易导出另一个结论,如果经常对字符串进行各种各样的修改,或者说,不可预见的修改,那么使用String来代表字符串的话会引起很大的内存开销。因为 String对象建立之后不能再改变,所以对于每一个不同的字符串,都需要一个String对象来表示。这时,应该考虑使用StringBuffer类,它允许修改,而不是每个不同的字符串都要生成一个新的对象。并且,这两种类的对象转换十分容易。
        4、尽量少用静态变量,因为静态变量是全局的,GC不会回收的;
        5、尽量避免在类的构造函数里创建、初始化大量的对象,防止在调用其自身类的构造器时造成不必要的内存资源浪费,尤其是大对象,JVM会突然需要大量内存,这时必然会触发GC优化系统内存环境;显示的声明数组空间,而且申请数量还极大。         以下是初始化不同类型的对象需要消耗的时间:

    运算操作  
     示例   
     标准化时间
     
    本地赋值   
     i = n
     1.0
     
    实例赋值   
     this.i = n
     1.2
     
    方法调用   
     Funct()
     5.9
     
    新建对象   
     New Object()
     980
     
    新建数组   
     New int[10]
     3100
     

           
    从表1可以看出,新建一个对象需要980个单位的时间,是本地赋值时间的980倍,是方法调用时间的166倍,而新建一个数组所花费的时间就更多了。
        6、尽量在合适的场景下使用对象池技术以提高系统性能,缩减缩减开销,但是要注意对象池的尺寸不宜过大,及时清除无效对象释放内存资源,综合考虑应用运行环境的内存资源限制,避免过高估计运行环境所提供内存资源的数量。
        7、大集合对象拥有大数据量的业务对象的时候,可以考虑分块进行处理,然后解决一块释放一块的策略。
        8、不要在经常调用的方法中创建对象,尤其是忌讳在循环中创建对象。可以适当的使用hashtable,vector 创建一组对象容器,然后从容器中去取那些对象,而不用每次new之后又丢弃。
        9、一般都是发生在开启大型文件或跟数据库一次拿了太多的数据,造成 Out Of Memory Error 的状况,这时就大概要计算一下数据量的最大值是多少,并且设定所需最小及最大的内存空间值。
        10、尽量少用finalize函数 ,因为finalize()会加大GC的工作量,而GC相当于耗费系统的计算能力。
       11、不要过滥使用哈希表,有一定开发经验的开发人员经常会使用hash表(hash表在JDK中的一个实现就是HashMap)来缓存一些数据,从而提高系统的运行速度。比如使用HashMap缓存一些物料信息、人员信息等基础资料,这在提高系统速度的同时也加大了系统的内存占用,特别是当缓存的资料比较多的时候。其实我们可以使用操作系统中的缓存的概念来解决这个问题,也就是给被缓存的分配一个一定大小的缓存容器,按照一定的算法淘汰不需要继续缓存的对象,这样一方面会因为进行了对象缓存而提高了系统的运行效率,同时由于缓存容器不是无限制扩大,从而也减少了系统的内存占用。现在有很多开源的缓存实现项目,比如ehcache、oscache等,这些项目都实现了FIFO、MRU等常见的缓存算法

    http://www.apkbus.com/blog-104224-41052.html

    展开全文
  • Java的内存管理

    2011-06-20 14:27:00
    1、Java的内存管理就是对象的分配和释放问题。 在Java中,程序员需要通过关键字new为每个对象申请内存空间 (基本类型除外),所有的对象都在堆 (Heap)中分配空间。 对象的释放是由GC决定和执行的。 在Java中,内存的...

    1、Java的内存管理就是对象的分配和释放问题。
    在Java中,程序员需要通过关键字new为每个对象申请内存空间 (基本类型除外),所有的对象都在堆 (Heap)中分配空间。
    对象的释放是由GC决定和执行的。
    在Java中,内存的分配是由程序完成的,而内存的释放是有GC完成的,这种收支两条线的方法简化了程序员的工作。但也加重了JVM的工作。这也是Java程序运行速度较慢的原因之一。

    GC释放空间方法:
    监控每一个对象的运行状态,包括对象的申请、引用、被引用、赋值等。当该对象不再被引用时,释放对象。


    2、内存管理结构
    Java使用有向图的方式进行内存管理,对于程序的每一个时刻,我们都有一个有向图表示JVM的内存分配情况。

    将对象考虑为有向图的顶点,将引用关系考虑为图的有向边,有向边从引用者指向被引对象。另外,每个线程对象可以作为一个图的起始顶点,例如大多程序从main进程开始执行,那么该图就是以main进程顶点开始的一棵根树。在这个有向图中,根顶点可达的对象都是有效对象,GC将不回收这些对象。如果某个对象 (连通子图)与这个根顶点不可达(注意,该图为有向图),那么我们认为这个(这些)对象不再被引用,可以被GC回收。

    3、使用有向图方式管理内存的优缺点
    Java使用有向图的方式进行内存管理,可以消除引用循环的问题,例如有三个对象,相互引用,只要它们和根进程不可达的,那么GC也是可以回收它们的。
    这种方式的优点是管理内存的精度很高,但是效率较低。

    另外一种常用的内存管理技术是使用计数器,例如COM模型采用计数器方式管理构件,它与有向图相比,精度行低(很难处理循环引用的问题),但执行效率很高。

    ★ Java的内存泄露
    Java虽然由GC来回收内存,但也是存在泄露问题的,只是比C++小一点。

    1、与C++的比较
    c++所有对象的分配和回收都需要由用户来管理。即需要管理点,也需要管理边。若存在不可达的点,无法在回收分配给那个点的内存,导致内存泄露。存在无用的对象引用,自然也会导致内存泄露。
    Java由GC来管理内存回收,GC将回收不可达的对象占用的内存空间。所以,Java需要考虑的内存泄露问题主要是那些被引用但无用的对象——即指要管理边就可以。被引用但无用的对象,程序引用了该对象,但后续不会再使用它。它占用的内存空间就浪费了。
    如果存在对象的引用,这个对象就被定义为“活动的”,同时不会被释放。

    2、Java内存泄露处理
    处理Java的内存泄露问题:确认该对象不再会被使用。
    典型的做法——
    把对象数据成员设为null
    从集合中移除该对象
    注意,当局部变量不需要时,不需明显的设为null,因为一个方法执行完毕时,这些引用会自动被清理。

    例子:
    List myList=new ArrayList();
    for (int i=1;i<100; i++)
    {
    Object o=new Object();
    myList.add(o);
    o=null;
    }
    //此时,所有的Object对象都没有被释放,因为变量myList引用这些对象。

    当myList后来不再用到,将之设为null,释放所有它引用的对象。之后GC便会回收这些对象占用的内存。

    ★ 对GC操作
    对GC的操作并不一定能达到管理内存的效果。

    GC对于程序员来说基本是透明的,不可见的。我们只有几个函数可以访问GC,例如运行GC的函数System.gc(),System.。
    但是根据Java语言规范定义, System.gc()函数不保证JVM的垃圾收集器一定会执行。因为,不同的JVM实现者可能使用不同的算法管理GC。通常,GC的线程的优先级别较低。


    JVM调用GC的策略有很多种,有的是内存使用到达一定程度时,GC才开始工作,也有定时执行的,有的是平缓执行GC,有的是中断式执行GC。但通常来说,我们不需要关心这些。除非在一些特定的场合,GC的执行影响应用程序的性能,例如对于基于Web的实时系统,如网络游戏等,用户不希望GC突然中断应用程序执行而进行垃圾回收,那么我们需要调整GC的参数,让GC能够通过平缓的方式释放内存,例如将垃圾回收分解为一系列的小步骤执行,Sun提供的HotSpot JVM就支持这一特性。

    ★ 内存泄露检测
    市场上已有几种专业检查Java内存泄漏的工具,它们的基本工作原理大同小异,都是通过监测Java程序运行时,所有对象的申请、释放等动作,将内存管理的所有信息进行统计、分析、可视化。开发人员将根据这些信息判断程序是否有内存泄漏问题。这些工具包括Optimizeit Profiler,JProbe Profiler,JinSight , Rational 公司的Purify等。

    在运行过程中,我们可以随时观察内存的使用情况,通过这种方式,我们可以很快找到那些长期不被释放,并且不再使用的对象。我们通过检查这些对象的生存周期,确认其是否为内存泄露。







    ★ 软引用
    特点:只有当内存不够的时候才回收这类内存,同时又保证在Java抛出OutOfMemory异常之前,被设置为null。
    保证最大限度的使用内存而不引起OutOfMemory异常。
    在某些时候对软引用的使用会降低应用的运行效率与性能,例如:应用软引用的对象的初始化过程较为耗时,或者对象的状态在程序的运行过程中发生了变化,都会给重新创建对象与初始化对象带来不同程度的麻烦。







    用途:
    可以用于实现一些常用资源的缓存,实现Cache的功能
    处理一些占用内存大而且声明周期较长,但使用并不频繁的对象时应尽量应用该技术







    ★ java程序设计中有关内存管理的经验







    1.最基本的建议是尽早释放无用对象的引用。如:
    ...
    A a = new A();
    //应用a对象
    a = null; //当使用对象a之后主动将其设置为空
    ….
    注:如果a 是方法的返回值,不要做这样的处理,否则你从该方法中得到的返回值永远为空,而且这种错误不易被发现、排除







    2.尽量少用finalize函数。它会加大GC的工作量。
    3.如果需要使用经常用到的图片,可以使用soft应用类型。它尽可能把图片保存在内存中
    4.注意集合数据类型,包括数组、树、图、链表等数据结构,这些数据结构对GC来说,回收更为复杂。
    5.尽量避免在类的默认构造器中创建、初始化大量的对象,防止在调用其自类的构造器时造成不必要的内存资源浪费
    6.尽量避免强制系统做垃圾内存的回收,增长系统做垃圾回收的最终时间
    7.尽量避免显式申请数组空间
    8.尽量做远程方法调用类应用开发时使用瞬间值变量,除非远程调用端需要获取该瞬间值变量的值。
    9.尽量在合适的场景下使用对象池技术以提高系统性能。
    展开全文
  • JAVA的内存管理

    2015-05-09 10:08:29
    首先第一个问题,也是问比较普遍就是你了解java内存吗?java内存分为哪几种?解释内存栈(stack)、堆(heap)和静态存储区用法。 我们先来看一看深入理解Java虚拟机第2章内容 概述:  对于从事C和C++...

    网上总是有很多五花八门的面试题,可是回答的都不是很深入,因为自己将要面临着找工作,所以专门来整理一下自己的思路,和面试题。首先第一个问题,也是问的比较普遍的就是你了解java内存吗?java内存分为哪几种?解释内存中的栈(stack)、堆(heap)和静态存储区的用法。

    我们先来看一看深入理解Java虚拟机的第2章内容

    概述:


      对于从事C和C++程序开发的开发人员来说,在内存管理领域,他们既是拥有最高权力的皇帝,又是从事最基础工作的劳动人民—既拥有每

    一个对象的“所有权”,又担负着每一个对象生命开始到终结的维护责任。

      对于Java程序员来说,在虚拟机的自动内存管理机制的帮助下,不再需要为每一个new操作去写配对的delete/free代码,而且不容易出现

    内存泄漏和内存溢出问题,看起来由虚拟机管理内存一切都很美好。不过,也正是因为Java程序员把内存控制的权力交给了Java虚拟机,一旦

    出现内存泄漏和溢出方面的问题,如果不了解虚拟机是怎样使用内存的,那排查错误将会成为一项异常艰难的工作。

     

      运行时数据区域


      Java虚拟机在执行Java程序的过程中会把它所管理的内存划分为若干个不同的数据区域。这些区域都有各自的用途,以及创建和销毁的时

    间,有的区域随着虚拟机进程的启动而存在,有些区域则是依赖用户线程的启动和结束而建立和销毁。根据《Java虚拟机规范(第2版)》的规

    定,Java虚拟机所管理的内存将会包括以下几个运行时数据区域,如下图所示:

              

     

      程序计数器     

      程序计数器(Program Counter Register)是一块较小的内存空间,它的作用可以看做是当前线程所执行的字节码的行号指示器。在虚拟

    机的概念模型里(仅是概念模型,各种虚拟机可能会通过一些更高效的方式去实现),字节码解释器工作时就是通过改变这个计数器的值来选取

    下一条需要执行的字节码指令,分支、循环、跳转、异常处理、线程恢复等基础功能都需要依赖这个计数器来完成。 由于Java虚拟机的多线

    程是通过线程轮流切换并分配处理器执行时间的方式来实现的,在任何一个确定的时刻,一个处理器(对于多核处理器来说是一个内

    核)只会执行一条线程中的指令。因此,为了线程切换后能恢复到正确的执行位置,每条线程都需要有一个独立的程序计数器,各条

    线程之间的计数器互不影响,独立存储,我们称这类内存区域为“线程私有”的内存。 如果线程正在执行的是一个Java方法,这个计数器

    记录的是正在执行的虚拟机字节码指令的地址;如果正在执行的是Natvie方法,这个计数器值则为空(Undefined)。此内存区域是唯一一个

    Java虚拟机规范中没有规定任何OutOfMemoryError情况的区域。

     

      Java虚拟机栈

      与程序计数器一样,Java虚拟机栈(Java Virtual Machine Stacks)也是线程私有的,它的生命周期与线程相同。虚拟机栈描述的是Java

    方法执行的内存模型:每个方法被执行的时候都会同时创建一个栈帧(Stack Frame)用于存储局部变量表、操作栈、动态链接、方法出口

    信息。每一个方法被调用直至执行完成的过程,就对应着一个栈帧在虚拟机栈中从入栈到出栈的过程。

      经常有人把Java内存区分为堆内存(Heap)和栈内存(Stack),这种分法比较粗糙,Java内存区域的划分实际上远比这复杂。这种划分

    方式的流行只能说明大多数程序员最关注的、与对象内存分配关系最密切的内存区域是这两块。其中所指的“堆”在后面会专门讲述,而所指

    的“栈”就是现在讲的虚拟机栈,或者说是虚拟机栈中的局部变量表部分。

      局部变量表存放了编译期可知的各种基本数据类型(boolean、byte、char、short、int、float、long、double)、对象引用

    (reference类型),它不等同于对象本身,根据不同的虚拟机实现,它可能是一个指向对象起始地址的引用指针,也可能指向一个代表对象的

    句柄或者其他与此对象相关的位置)和returnAddress类型(指向了一条字节码指令的地址)。

      其中64位长度的long和double类型的数据会占用2个局部变量空间(Slot),其余的数据类型只占用1个。局部变量表所需的内存

    空间在编译期间完成分配,当进入一个方法时,这个方法需要在帧中分配多大的局部变量空间是完全确定的,在方法运行期间不会改

    变局部变量表的大小。在Java虚拟机规范中,对这个区域规定了两种异常状况:如果线程请求的栈深度大于虚拟机所允许的深度,将抛出

    StackOverflowError异常;如果虚拟机栈可以动态扩展(当前大部分的Java虚拟机都可动态扩展,只不过Java虚拟机规范中也允许固定长度的

    虚拟机栈),当扩展时无法申请到足够的内存时会抛出OutOfMemoryError异常。

     

      本地方法栈

      本地方法栈(Native Method Stacks)与虚拟机栈所发挥的作用是非常相似的,其区别不过是虚拟机栈为虚拟机执行Java方法(也就是字

    节码)服务,而本地方法栈则是为虚拟机使用到的Native方法服务。虚拟机规范中对本地方法栈中的方法使用的语言、使用方式与数据结构并没

    有强制规定,因此具体的虚拟机可以自由实现它。甚至有的虚拟机(譬如Sun HotSpot虚拟机)直接就把本地方法栈和虚拟机栈合二为一。与

    虚拟机栈一样,本地方法栈区域也会抛出StackOverflowError和OutOfMemoryError异常。

     

      Java堆

      对于大多数应用来说,Java堆(Java Heap)是Java虚拟机所管理的内存中最大的一块。Java堆是被所有线程共享的一块内存区域,在虚拟机启动时创建。此内

    存区域的唯一目的就是存放对象实例,几乎所有的对象实例都在这里分配内存。这一点在Java虚拟机规范中的描述是:所有的对象实例以及数组都要在堆上分配,

    但是随着JIT编译器的发展与逃逸分析技术的逐渐成熟,栈上分配、标量替换优化技术将会导致一些微妙的变化发生,所有的对象都分配在堆上也渐渐变得不是那么“绝

    对”了。

      Java堆是垃圾收集器管理的主要区域,因此很多时候也被称做“GC堆”(Garbage Collected Heap,幸好国内没翻译成“垃圾堆”)。如果从内存回收的角度看,

    由于现在收集器基本都是采用的分代收集算法,所以Java堆中还可以细分为:新生代和老年代;再细致一点的有Eden空间、From Survivor空间、To Survivor空间

    等。如果从内存分配的角度看,线程共享的Java堆中可能划分出多个线程私有的分配缓冲区(Thread Local Allocation Buffer,TLAB)。不过,无论如何划

    分,都与存放内容无关,无论哪个区域,存储的都仍然是对象实例,进一步划分的目的是为了更好地回收内存,或者更快地分配内存。在本章中,我们仅仅针对内存区

    域的作用进行讨论,Java堆中的上述各个区域的分配和回收等细节将会是下一章的主题。

      根据Java虚拟机规范的规定,Java堆可以处于物理上不连续的内存空间中,只要逻辑上是连续的即可,就像我们的磁盘空间一样。在实现时,既可以实现成固定

    大小的,也可以是可扩展的,不过当前主流的虚拟机都是按照可扩展来实现的(通过-Xmx和-Xms控制)。如果在堆中没有内存完成实例分配,并且堆也无法再扩展

    时,将会抛出OutOfMemoryError异常。

     

      方法区

      方法区(Method Area)与Java堆一样,是各个线程共享的内存区域,它用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等

    数据。虽然Java虚拟机规范把方法区描述为堆的一个逻辑部分,但是它却有一个别名叫做Non-Heap(非堆),目的应该是与Java堆区分开来。

      对于习惯在HotSpot虚拟机上开发和部署程序的开发者来说,很多人愿意把方法区称为“永久代”(Permanent Generation),本质上两者并不等价,仅仅是因

    为HotSpot虚拟机的设计团队选择把GC分代收集扩展至方法区,或者说使用永久代来实现方法区而已。对于其他虚拟机(如BEA JRockit、IBM J9等)来说是不存在

    永久代的概念的。即使是HotSpot虚拟机本身,根据官方发布的路线图信息,现在也有放弃永久代并“搬家”至Native Memory来实现方法区的规划了。

      Java虚拟机规范对这个区域的限制非常宽松,除了和Java堆一样不需要连续的内存和可以选择固定大小或者可扩展外,还可以选择不实现垃圾收集。相对而言,

    垃圾收集行为在这个区域是比较少出现的,但并非数据进入了方法区就如永久代的名字一样“永久”存在了。这个区域的内存回收目标主要是针对常量池的回收和对类型

    的卸载,一般来说这个区域的回收“成绩”比较难以令人满意,尤其是类型的卸载,条件相当苛刻,但是这部分区域的回收确实是有必要的。在Sun公司的BUG列表中,

      曾出现过的若干个严重的BUG就是由于低版本的HotSpot虚拟机对此区域未完全回收而导致内存泄漏。 根据Java虚拟机规范的规定,当方法区无法满足内存分配

    需求时,将抛出OutOfMemoryError异常。

     

      运行时常量池

      运行时常量池(Runtime Constant Pool)是方法区的一部分。Class文件中除了有类的版本、字段、方法、接口等描述等信息外,还有一项信息是常量池

    (Constant Pool Table),用于存放编译期生成的各种字面量和符号引用,这部分内容将在类加载后存放到方法区的运行时常量池中。 Java虚拟机对Class

    文件的每一部分(自然也包括常量池)的格式都有严格的规定,每一个字节用于存储哪种数据都必须符合规范上的要求,这样才会被虚拟机认可、装载和执行。但对于

      运行时常量池,Java虚拟机规范没有做任何细节的要求,不同的提供商实现的虚拟机可以按照自己的需要来实现这个内存区域。不过,一般来说,除了保存Class

    文件中描述的符号引用外,还会把翻译出来的直接引用也存储在运行时常量池中。 运行时常量池相对于Class文件常量池的另外一个重要特征是具备动态性,Java语言

    并不要求常量一定只能在编译期产生,也就是并非预置入Class文件中常量池的内容才能进入方法区运行时常量池,运行期间也可能将新的常量放入池中,这种特性被

    开发人员利用得比较多的便是String类的intern()方法。 既然运行时常量池是方法区的一部分,自然会受到方法区内存的限制,当常量池无法再申请到内存时会抛出

    OutOfMemoryError异常。

     

      对象访问


      介绍完Java虚拟机的运行时数据区之后,我们就可以来探讨一个问题:在Java语言中,对象访问是如何进行的?对象访问在Java语言中无处不在,是最普通的程

    序行为,但即使是最简单的访问,也会却涉及Java栈、Java堆、方法区这三个最重要内存区域之间的关联关系,如下面的这句代码:

              Object obj = new Object();

    假设这句代码出现在方法体中,那“Object obj”这部分的语义将会反映到Java栈的本地变量表中,作为一个reference类型数据出现。而“new Object()”这部分的语

    义将会反映到Java堆中,形成一块存储了Object类型所有实例数据值(Instance Data,对象中各个实例字段的数据)的结构化内存,根据具体类型以及虚拟机实现

    的对象内存布局(Object Memory Layout)的不同,这块内存的长度是不固定的。另外,在Java堆中还必须包含能查找到此对象类型数据(如对象类型、父类、实

    现的接口、方法等)的地址信息,这些类型数据则存储在方法区中。

      由于reference类型在Java虚拟机规范里面只规定了一个指向对象的引用,并没有定义这个引用应该通过哪种方式去定位,以及访问到Java堆中的对

    象的具体位置,因此不同虚拟机实现的对象访问方式会有所不同,主流的访问方式有两种:使用句柄和直接指针如果使用句柄访问方式,Java堆中将会

    划分出一块内存来作为句柄池,reference中存储的就是对象的句柄地址,而句柄中包含了对象实例数据和类型数据各自的具体地址信息,如下图所示:

     

          

      如果使用的是直接指针访问方式,Java 堆对象的布局中就必须考虑如何放置访问类型数据的相关信息,reference中直接存储的就是对象地址,如下

    图所示:

          

      这两种对象的访问方式各有优势,使用句柄访问方式的最大好处就是reference中存储的是稳定的句柄地址,在对象被移动(垃圾收集时移动对象是非

    常普遍的行为)时只会改变句柄中的实例数据指针,而reference本身不需要被修改。使用直接指针访问方式的最大好处就是速度更快,它节省了一次指针

    定位的时间开销,由于对象的访问在Java中非常频繁,因此这类开销积少成多后也是一项非常可观的执行成本。就本书讨论的主要虚拟机Sun HotSpot而

    言,它是使用第二种方式进行对象访问的,但从整个软件开发的范围来看,各种语言和框架使用句柄来访问的情况也十分常见。

    上面的属于JAVA运行时内存。下面我们再看看JAVA所有的内存,一下内容摘自百度百科;

     (1)   寄存器(Registers)。这是速度最快的存储场所,因为寄存器其他所有存储媒介都不同:它位于处理器内部。不过,寄存器的数量十分有限,所以寄存器是根据需要由编译器适当地分配。作为一个程序员,我们对此没有直接的控制权,也没办法在程序里头感觉到寄存器的任何存在迹象。   
        
              (2)   Stack(栈)。位于一般的RAM(random-access   memory,随机访问内存)中。处理器通过其指针(“栈指针”,stack   pointer)获得处理的直接支持。栈指针若向下(后)移,会分配新的内存;若向上(前)移,则会释放那些内存。这是一种特别快、特别有效率的数据存储方式,速度仅次于寄存器。由于Java编译器有责任产生“将stack指针前后移动”的程序代码,所以它必须能够完全掌握它所编译的程序中“存在stack里头的所有数据的实际大小和存活时间”。如此一来便会限制程序的弹性。由于这个限制,尽管有些Java数据要存储在栈里——特别是对象句柄,但Java对象并不放到其中。   
        
              (3)   Heap(堆)。Heap是一种通用性质的内存存储空间(也存在于RAM中),用来置放所有Java对象。“内存堆”或“堆”(Heap)胜过stack之处在于,编译器不需知道究竟得从堆里分配多少存储空间,也不需知道从堆上分配的空间究竟要存活多长的时间。因此,用堆存储数据时会得到更大的灵活性。要求创建一个对象时,只需用new即可。执行这些代码时,会在堆里分配空间。当然,为达到这种灵活性,必然会付出一定的代价:在堆里分配存储空间时会比从栈里分配花掉更长的时间(假设你真的可以在Java中像C++一样地从stack上产生对象的话)!   
        
              (4)   静态存储空间(Static   storage)。这儿的“静态”(Static)是指“位于固定位置”(也在RAM里头)。静态存储空间存放着“程序运行期间”一直存在的数据。可用static关键字将某个对象内的特定成员设为静态,但Java对象本身永远都不会置入静态存储空间。   
        
              (5)   常量存储空间(Constant   storage)。常量值通常被直接置于程序代码里头。因为它们永远都不会改变,所以也是安全的。有的常数需要严格地保护,所以可考虑将它们置入只读存储器(read-only   memory,ROM)中。   
        
              (6)   非RAM存储空间(Non-RAM   storage)。若数据完全存活于程序之外,则程序不运行时数据仍继续存在,脱离了程序的控制范围。其中两个最主要的例子便是“串流化对象(streamed   objects)”和“持久性对象(persistent   objects)”。在串流化对象形式中,对象会被转换为一连串的字节(bytes)流,这些bytes通常会被传送给另一台机器。而在持久性对象形式中,对象被存储于磁盘,即使程序运行结束,这些对象还能够继续保有。这种类型的存储空间的特点在于,它们能够将对象转换为可存储于其他媒介的形式,并在需要时,将所存储的数据还原成可存储于RAM中的一般对象。Java提供了对“轻量级持久性(Lightweight   persistence)”的支持。新版本有可能提供更完善的解决方案。
    接下来加上自己的一些理解。






    展开全文
  • Java 的内存管理机制是怎样的?

    Java 的内存管理机制是怎样的?

    展开全文
  • 详细介绍Java的内存管理与内存泄露 作为Internet最流行的编程语言之一,Java现正非常流行。我们的网络应用程序就主要采用Java语言开发,大体上分为客户端、服务器和数据库三个层次。在进入测试过程中,...
  • 浅谈java的内存管理机制

    千次阅读 2013-05-04 10:41:39
    浅谈java的内存管理机制  内存管理(百度百科定义):是指软件运行时对计算机内存资源的分配和使用的技术。其最主要的目的是如何高效,快速的分配,并且在适当的时候释放和回收内存资源。 从上面的定义中我们...
  • 关于分布式程序 java的内存管理浅谈

    千次阅读 2015-06-02 14:40:39
    关于分布式程序 java的内存管理浅谈,转述了一些之前看到的关于java memory的一些文章片段,列了几个在java memory管理上比较优秀的框架,大家可以参考一下。
  • 初探JAVA的内存管理

    千次阅读 2005-04-07 09:10:00
    初探JAVA的内存管理 概要:本文论述在JAVA编程方式中,是如何进行内存管理的。内存管理主要涉及对象的创建与对象的回收,其回收主要由JAVA的垃圾收集器来完成。但虽然有垃圾收集机制来帮助程序员完成很多工作,仍然...
  • 题目描述如下:编写一个程序,包括两个线程,一个线程用于模拟内存分配活动,另一个用于跟踪第一个线程的内存行为,要求两个线程之间通过信号量实现同步,模拟内存活动的线程可以从一个文件中读出要进行的内存操作。...
  • Java的内存管理机制

    2013-10-13 21:28:09
    当在一段代码块定义一个变量时,Java 就在栈中为这个变量分配内存空间,当超过变量的作用域后,Java 会自动释放掉为该变量分配的内存空间,该内存空间可以立即被另作它用。  堆内存用来存放由 new 创建的对象和数...
  • Java的内存控制和管理技巧;
  • java的内存管理实例

    2015-01-23 17:52:31
    Java程序多个部分(方法,变量,对象)驻留在内存中以下两个位置:即堆和栈,现在我们只关心三类事物:实例变量,局部变量和对象: 实例变量和对象驻留在堆上 局部变量驻留在栈上 让我们查看一个 java 程序,看看...
  • Java内存泄漏是每个Java程序员都会遇到问题,程序在本地运行一切正常,可是布署到远端就会出现内存无限制增长,最后系统瘫痪,那么如何最快最好检测程序稳定性,防止系统崩盘,作者用自已亲身经历与各位...
  • Java的内存分配有三种, 1、静态存储区:内存在程序编译时就分配好了,比如静态变量; 2、栈区:各种原始数据类型的局部变量都是在栈上创建的,当程序退出该变量的作用范围的时候,这个变量的内存会被自动释放。 3、...
  • 作者:developerHaoz地址:...对于 Java 程序员来说,在 Java 虚拟机自动内存管理机制帮助下,不再需要为每一个 new 操作去写对应 delete/free 代码,不容易出现内存泄露和内存溢出问题。不过,也正是因为 Java
  • 通常Java的缓存管理会由垃圾回收器(Java Garbage Collection)定时处理,无须程序员操心。但Java Garbage Collection仅有权回收那些非“强引用”(Strong Reference)类型的类。也就是说,如果程序生成大量的强引用...
  • 这里用一些简单的例子看一下JVM的内存使用与管理方式。 1.建立一简单程式,查看默认情况下JVM可使用的最大内存public class MemoryDemo{ public static void main(String[] args){ System.out.println(Runtime....
  • Java内存管理

    千次阅读 2016-06-06 20:28:53
    而且了解了Java的内存管理,有助于优化JVM,从而使得自己的应用获得最佳的性能体验。所以还等什么,赶紧跟着我来一起学习这方面的知识吧~ Java内存管理分为两个方面:内存分配和垃圾回收,下面我们一一的来看一下。 ...
  • Java的内存管理就是对象的分配和释放问题。(两部分)  分配 :内存的分配是由程序完成的,程序员需要通过关键字new 为每个对象申请内存空间 (基本类型除外),所有的对象都在堆 (Heap)中分配空间。  释放 :对象的...
  • Java 内存管理

    2015-07-30 16:09:21
    若要弄明白Java的内存管理,首先需要明白Java虚拟机是如何对内存进行划分的。若要彻底了解JVM对内存的划分,需要从多个方面来考虑,如运行时的内存划分、GC内存划分等。 1、 运行时内存 当一个.class文件被类加载子...
  • java内存管理

    2016-08-29 23:08:30
     Java的内存管理就是对象的分配和释放问题。(两部分)  分配 :内存的分配是由程序完成的,程序员需要通过关键字new 为每个对象申请内存空间 (基本类型除外),所有的对象都在堆 (Heap)中分配空间。 释放 :对象...
  • JavaJava内存管理

    2015-07-30 23:42:19
    Java的内存管理其实是指对象 的分配和释放问题。曾经看过这样一句话:“C++程序员觉得内存管理太重要了,所以一定要自己进行管理,而Java程序员觉得内存管理太重要了,一定不能自己管理”。我觉得这句话说得太精辟了...
  • java内存管理原理

    2018-04-30 09:43:00
    java内存管理原理(1) 请描述java的内存管理原理在java中,有java程序、虚拟机、操作系统三个层次,其中java程序与虚拟机交互,而虚拟机与操作系统交互。这也就保证了java的与平台无关性1.程序运行前:JVM向操作...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 29,975
精华内容 11,990
关键字:

java的内存管理

java 订阅