童鞋们帮我解答一下线程的内存回收机制，最好是能够画图或者写一段代码来说明，这样看的懂一点。

如果问题已经解决，再次编辑，修改主题类型为已解决，方便大家查看
否则继续追问

zZZ~~ 发表于 2013-5-30 22:19
你也要进4期的物联云班么？

是呀，听说压力挺大的！

线程的生命周期。。。。。

Changer_s 发表于 2013-5-30 21:45
冒昧的问一下我的理解是不是对的：
1>如果有对象应用了，并且使用了引用的地址的对象，就是可达状态，也 ...

你也要进4期的物联云班么？

Changer_s 发表于 2013-5-30 21:45
冒昧的问一下我的理解是不是对的：
1>如果有对象应用了，并且使用了引用的地址的对象，就是可达状态，也 ...

你的理解没错啊 。。。。。。。。

zZZ~~ 发表于 2013-5-30 21:29
认真点看完 你会有收获 而且这也不多啊

冒昧的问一下我的理解是不是对的：
1>如果有对象应用了，并且使用了引用的地址的对象，就是可达状态，也就不会被回收
2>如果有对象虽然引用了，但是一直没用，系统会调用finalize()方法，判断该对象是否再被使用，
如果是则是可恢复状态，就不会被回收；如果还是没有被调用，就是不可达状态，也就是直接被回收呢？

Changer_s 发表于 2013-5-30 21:25
果断好多！有简短一点的吗？

认真点看完 你会有收获 而且这也不多啊

zZZ~~ 发表于 2013-5-30 20:08
1.Java在内存中的状态
首先我们先写一个代码为例子：

果断好多！有简短一点的吗？

顾玲玉 发表于 2013-5-30 19:49
1．垃圾收集算法的核心思想
Java语言建立了垃圾收集机制，用以跟踪正在使用的对象和发现并回收不再使用（引 ...

我个妈呀！！！这么多？:funk:

1.Java在内存中的状态
首先我们先写一个代码为例子：

Person.java

Java代码
packagetest;

importjava.io.Serializable;

publicclassPerson implementsSerializable {

  staticfinallongserialVersionUID = 1L;

  String name; // 姓名
   
  Person friend;  //朋友

  publicPerson() {}
   
  publicPerson(String name) {
    super();
    this.name = name;
  }
}

package test;

import java.io.Serializable;

public class Person implements Serializable {

  static final long serialVersionUID = 1L;

  String name; // 姓名
  
  Person friend;  //朋友

  public Person() {}
  
  public Person(String name) {
    super();
    this.name = name;
  }
}Test.java
Java代码
packagetest;


publicclassTest{

  publicstaticvoidmain(String[] args) {
    Person p1 = newPerson("Kevin");
    Person p2 = newPerson("Rain");
    Person p3 = newPerson("Sunny");
     
    p1.friend = p2;
    p3 = p2;
    p2 = null;
  }
}

package test;


public class Test{

  public static void main(String[] args) {
    Person p1 = new Person("Kevin");
    Person p2 = new Person("Rain");
    Person p3 = new Person("Sunny");
   
    p1.friend = p2;
    p3 = p2;
    p2 = null;
  }
}把上面Test.java中main方面里面的对象引用画成一个从main方法开始的对象引用图的话就是这样的（顶点是对象和引用，有向边是引用关系）：


当程序运行起来之后，把它在内存中的状态看成是有向图后，可以分为三种：

1）可达状态：在一个对象创建后，有一个以上的引用变量引用它。在有向图中可以从起始顶点导航到该对象，那它就处于可达状态。

2）可恢复状态：如果程序中某个对象不再有任何的引用变量引用它，它将先进入可恢复状态，此时从有向图的起始顶点不能再导航到该对象。在这个状态下，系统的垃圾回收机制准备回收该对象的所占用的内存，在回收之前，系统会调用finalize()方法进行资源清理，如果资源整理后重新让一个以上引用变量引用该对象，则这个对象会再次变为可达状态；否则就会进入不可达状态。

3）不可达状态：当对象的所有关联都被切断，且系统调用finalize()方法进行资源清理后依旧没有使该对象变为可达状态，则这个对象将永久性失去引用并且变成不可达状态，系统才会真正的去回收该对象所占用的资源。上述三种状态的转换图如下：


2.Java对对象的4种引用

1）强引用 ：创建一个对象并把这个对象直接赋给一个变量，eg ：Person person = new Person("sunny"); 不管系统资源有么的紧张，强引用的对象都绝对不会被回收，即使他以后不会再用到。

2）软引用 ：通过SoftReference类实现，eg : SoftReference<erson> p = new SoftReference<erson>(new Person("Rain"));,内存非常紧张的时候会被回收，其他时候不会被回收，所以在使用之前要判断是否为null从而判断他是否已经被回收了。

3）弱引用 ：通过WeakReference类实现，eg : WeakReference<erson> p = new WeakReference<erson>(new Person("Rain"));不管内存是否足够，系统垃圾回收时必定会回收。

4）虚引用 ：不能单独使用，主要是用于追踪对象被垃圾回收的状态。

通过PhantomReference类和引用队列ReferenceQueue类联合使用实现，eg ：

Java代码
packagetest;

importjava.lang.ref.PhantomReference;
importjava.lang.ref.ReferenceQueue;


publicclassTest{

  publicstaticvoidmain(String[] args) {
    //创建一个对象
    Person person = newPerson("Sunny");   
    //创建一个引用队列   
    ReferenceQueue<'\"0\"'alt='\"\"'src='\"static/image/smiley/default/titter.gif\"'smilieid='\"9\"'>erson> rq = newReferenceQueue<'\"0\"'alt='\"\"'src='\"static/image/smiley/default/titter.gif\"'smilieid='\"9\"'>erson>();
    //创建一个虚引用，让此虚引用引用到person对象
    PhantomReference<'\"0\"'alt='\"\"'src='\"static/image/smiley/default/titter.gif\"'smilieid='\"9\"'>erson> pr = newPhantomReference<'\"0\"'alt='\"\"'src='\"static/image/smiley/default/titter.gif\"'smilieid='\"9\"'>erson>(person, rq);
    //切断person引用变量和对象的引用
    person = null;
    //试图取出虚引用所引用的对象
    //发现程序并不能通过虚引用访问被引用对象，所以此处输出为null
    System.out.println(pr.get());
    //强制垃圾回收
    System.gc();
    System.runFinalization();
    //因为一旦虚引用中的对象被回收后，该虚引用就会进入引用队列中
    //所以用队列中最先进入队列中引用与pr进行比较，输出true
    System.out.println(rq.poll() == pr);
  }
}

package test;

import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;


public class Test{

  public static void main(String[] args) {
    //创建一个对象
    Person person = new Person("Sunny");  
    //创建一个引用队列  
    ReferenceQueue<erson> rq = new ReferenceQueue<erson>();
    //创建一个虚引用，让此虚引用引用到person对象
    PhantomReference<erson> pr = new PhantomReference<erson>(person, rq);
    //切断person引用变量和对象的引用
    person = null;
    //试图取出虚引用所引用的对象
    //发现程序并不能通过虚引用访问被引用对象，所以此处输出为null
    System.out.println(pr.get());
    //强制垃圾回收
    System.gc();
    System.runFinalization();
    //因为一旦虚引用中的对象被回收后，该虚引用就会进入引用队列中
    //所以用队列中最先进入队列中引用与pr进行比较，输出true
    System.out.println(rq.poll() == pr);
  }
}运行结果：
3.Java垃圾回收机制
其实Java垃圾回收主要做的是两件事：1）内存回收 2）碎片整理
3.1垃圾回收算法
1）串行回收（只用一个CPU）和并行回收（多个CPU才有用）：串行回收是不管系统有多少个CPU，始终只用一个CPU来执行垃圾回收操作，而并行回收就是把整个回收工作拆分成多个部分，每个部分由一个CPU负责，从而让多个CPU并行回收。并行回收的执行效率很高，但复杂度增加，另外也有一些副作用，如内存碎片增加。

2）并发执行和应用程序停止 ：应用程序停止（Stop-the-world）顾名思义，其垃圾回收方式在执行垃圾回收的同时会导致应用程序的暂停。并发执行的垃圾回收虽然不会导致应用程序的暂停，但由于并发执行垃圾需要解决和应用程序的执行冲突（应用程序可能在垃圾回收的过程修改对象），因此并发执行垃圾回收的系统开销比Stop-the-world高，而且执行时需要更多的堆内存。

3）压缩和不压缩和复制 ：
①支持压缩的垃圾回收器（标记-压缩 = 标记清除+压缩）会把所有的可达对象搬迁到一端，然后直接清理掉端边界以外的内存，减少了内存碎片。
②不压缩的垃圾回收器（标记-清除）要遍历两次，第一次先从跟开始访问所有可达对象，并将他们标记为可达状态，第二次便利整个内存区域，对未标记可达状态的对象进行回收处理。这种回收方式不压缩，不需要额外内存，但要两次遍历，会产生碎片
③复制式的垃圾回收器：将堆内存分成两个相同空间，从根（类似于前面的有向图起始顶点）开始访问每一个关联的可达对象，将空间A的全部可达对象复制到空间B，然后一次性回收空间A。对于该算法而言，因为只需访问所有的可达对象，将所有的可达对象复制走之后就直接回收整个空间，完全不用理会不可达对象，所以遍历空间的成本较小，但需要巨大的复制成本和较多的内存。


3.2堆内存的分代回收
1）分代回收的依据：①对象生存时间的长短：大部分对象在Young期间就被回收②不同代采取不同的垃圾回收策略：新（生存时间短）老（生存时间长）对象之间很少存在引用

2) 堆内存的分代：①Young代 ：
Ⅰ回收机制 ：因为对象数量少，所以采用复制回收。
Ⅱ组成区域 ：由1个Eden区和2个Survivor区构成，同一时间的两个Survivor区，一个用来保存对象，另一个是空的；每次进行Young代垃圾回收的时候，就把Eden，From中的可达对象复制到To区域中，一些生存时间长的就复制到了老年代，接着清除Eden，From空间，最后原来的To空间变为From空间，原来的From空间变为To空间。Ⅲ对象来源 ：绝大多数对象先分配到Eden区，一些大的对象会直接被分配到Old代中。
Ⅳ回收频率 ：因为Young代对象大部分很快进入不可达状态，因此回收频率高且回收速度快

如果问题已经解决，请把帖子的类型改为“已解决”

顾玲玉 发表于 2013-5-30 19:49
1．垃圾收集算法的核心思想
Java语言建立了垃圾收集机制，用以跟踪正在使用的对象和发现并回收不再使用（引 ...

{:soso_e179:}

1．垃圾收集算法的核心思想
Java语言建立了垃圾收集机制，用以跟踪正在使用的对象和发现并回收不再使用（引用）的对象。该机制可以有效防范动态内存分配中可能发生的两个危险：因内存垃圾过多而引发的内存耗尽，以及不恰当的内存释放所造成的内存非法引用。
垃圾收集算法的核心思想是：对虚拟机可用内存空间，即堆空间中的对象进行识别，如果对象正在被引用，那么称其为存活对象，反之，如果对象不再被引用，则为垃圾对象，可以回收其占据的空间，用于再分配。垃圾收集算法的选择和垃圾收集系统参数的合理调节直接影响着系统性能，因此需要开发人员做比较深入的了解。

2．触发主GC（Garbage Collector）的条件
JVM进行次GC的频率很高,但因为这种GC占用时间极短,所以对系统产生的影响不大。更值得关注的是主GC的触发条件,因为它对系统影响很明显。总的来说,有两个条件会触发主GC:
①当应用程序空闲时,即没有应用线程在运行时,GC会被调用。因为GC在优先级最低的线程中进行,所以当应用忙时,GC线程就不会被调用,但以下条件除外。
②Java堆内存不足时,GC会被调用。当应用线程在运行,并在运行过程中创建新对象,若这时内存空间不足,JVM就会强制地调用GC线程,以便回收内存用于新的分配。若GC一次之后仍不能满足内存分配的要求,JVM会再进行两次GC作进一步的尝试,若仍无法满足要求,则 JVM将报“out of memory”的错误,Java应用将停止。
由于是否进行主GC由JVM根据系统环境决定,而系统环境在不断的变化当中,所以主GC的运行具有不确定性,无法预计它何时必然出现,但可以确定的是对一个长期运行的应用来说,其主GC是反复进行的。

3．减少GC开销的措施
根据上述GC的机制,程序的运行会直接影响系统环境的变化,从而影响GC的触发。若不针对GC的特点进行设计和编码,就会出现内存驻留等一系列负面影响。为了避免这些影响,基本的原则就是尽可能地减少垃圾和减少GC过程中的开销。具体措施包括以下几个方面:
(1)不要显式调用System.gc()
此函数建议JVM进行主GC,虽然只是建议而非一定,但很多情况下它会触发主GC,从而增加主GC的频率,也即增加了间歇性停顿的次数。

(2)尽量减少临时对象的使用
临时对象在跳出函数调用后,会成为垃圾,少用临时变量就相当于减少了垃圾的产生,从而延长了出现上述第二个触发条件出现的时间,减少了主GC的机会。

(3)对象不用时最好显式置为Null
一般而言,为Null的对象都会被作为垃圾处理,所以将不用的对象显式地设为Null,有利于GC收集器判定垃圾,从而提高了GC的效率。

(4)尽量使用StringBuffer,而不用String来累加字符串（详见blog另一篇文章JAVA中String与StringBuffer）
由于String是固定长的字符串对象,累加String对象时,并非在一个String对象中扩增,而是重新创建新的String对象,如Str5=Str1+Str2+Str3+Str4,这条语句执行过程中会产生多个垃圾对象,因为对次作“+”操作时都必须创建新的String对象,但这些过渡对象对系统来说是没有实际意义的,只会增加更多的垃圾。避免这种情况可以改用StringBuffer来累加字符串,因StringBuffer是可变长的,它在原有基础上进行扩增,不会产生中间对象。

(5)能用基本类型如Int,Long,就不用Integer,Long对象
基本类型变量占用的内存资源比相应对象占用的少得多,如果没有必要,最好使用基本变量。

(6)尽量少用静态对象变量
静态变量属于全局变量,不会被GC回收,它们会一直占用内存。

(7)分散对象创建或删除的时间
集中在短时间内大量创建新对象,特别是大对象,会导致突然需要大量内存,JVM在面临这种情况时,只能进行主GC,以回收内存或整合内存碎片,从而增加主GC的频率。集中删除对象,道理也是一样的。它使得突然出现了大量的垃圾对象,空闲空间必然减少,从而大大增加了下一次创建新对象时强制主GC的机会。

4．gc与finalize方法
⑴gc方法请求垃圾回收
使用System.gc()可以不管JVM使用的是哪一种垃圾回收的算法，都可以请求Java的垃圾回收。需要注意的是，调用System.gc()也仅仅是一个请求。JVM接受这个消息后，并不是立即做垃圾回收，而只是对几个垃圾回收算法做了加权，使垃圾回收操作容易发生，或提早发生，或回收较多而已。

⑵finalize方法透视垃圾收集器的运行
在JVM垃圾收集器收集一个对象之前 ，一般要求程序调用适当的方法释放资源，但在没有明确释放资源的情况下，Java提供了缺省机制来终止化该对象释放资源，这个方法就是finalize（）。它的原型为：
protected void finalize() throws Throwable
在finalize()方法返回之后，对象消失，垃圾收集开始执行。原型中的throws Throwable表示它可以抛出任何类型的异常。
因此，当对象即将被销毁时，有时需要做一些善后工作。可以把这些操作写在finalize()方法里。
protected void finalize()
{
// finalization code here
}

⑶代码示例

class Garbage
{
    int index;
    static int count;
    Garbage()
    {
        count++;
        System.out.println("object "+count+" construct");
        setID(count);
    }
   
    void setID(int id)
    {
        index=id;
    }
   
    protected void finalize() //重写finalize方法
    {
        System.out.println("object "+index+" is reclaimed");
    }
   
    public static void main(String[] args)
    {
        new Garbage();
        new Garbage();
        new Garbage();
        new Garbage();
        System.gc(); //请求运行垃圾收集器
    }
}

5．Java 内存泄漏
由于采用了垃圾回收机制，任何不可达对象（对象不再被引用）都可以由垃圾收集线程回收。因此通常说的Java 内存泄漏其实是指无意识的、非故意的对象引用，或者无意识的对象保持。无意识的对象引用是指代码的开发人员本来已经对对象使用完毕，却因为编码的错误而意外地保存了对该对象的引用（这个引用的存在并不是编码人员的主观意愿），从而使得该对象一直无法被垃圾回收器回收掉，这种本来以为可以释放掉的却最终未能被释放的空间可以认为是被“泄漏了”。
考虑下面的程序,在ObjStack类中,使用push和pop方法来管理堆栈中的对象。两个方法中的索引(index)用于指示堆栈中下一个可用位置。push方法存储对新对象的引用并增加索引值,而pop方法减小索引值并返回堆栈最上面的元素。在main方法中,创建了容量为64的栈,并64次调用push方法向它添加对象,此时index的值为64,随后又32次调用pop方法,则index的值变为32,出栈意味着在堆栈中的空间应该被收集。但事实上,pop方法只是减小了索引值,堆栈仍然保持着对那些对象的引用。故32个无用对象不会被GC回收,造成了内存渗漏。
百度找的 希望对你有用