JAVA对象与垃圾回收

JAVA对象与垃圾回收

      我们在一开始的时候就说过，JAVA的垃圾回收是JAVA语言的重要功能之一，当程序创建对象，数组等引用类型实体时，系统都会在堆内存中为之分配一块内存区，对象就保存在这块内存区中，当这块内存不再被任何引用变量引用时，这块内存就变成垃圾，等待垃圾回收机制进行回收。

 

》垃圾回收机制只负责回收堆内存中的对象，不会回收任何物理资源（例如数据库连接，网络IO等资源）

 

》程序无法精确控制垃圾回收的运行，垃圾回收会在合适时候进行。当对象永久地失去引用后，系统就会在合适时候回收它所占用的内存

 

》垃圾回收机制回收任何对象之前，总会先调用它的finalize方法，该方法可能使该对象重新复活（让一个引用变量重新引用该对象），从而导致垃圾回收机制取消回收。

 

 

对象在内存中的状态

 

当一个对象在堆内存中运行时，根据它被引用变量所引用的状态，可以分为三种：

 

》激活状态：

 

》去活状态：

 

》死亡状态：

 

大家看个图就容易理解了：

 

 

下面代码简单地创建了两个字符串对象，并创建了一个引用变量依次指向两个对象。

 

public class StatusTranfer

{

         public static void test()

         {

                     String a = new String("世界您好");      //1

                     a = new String("您好世界");            //2

          }

 

          public static void main(String[] args)

          {

                     test();        //3

            }

}

 

当程序执行test方法中的1代码时，代码定义了一个a变量，并让该变量指向“世界您好”字符串，该代码执行结束后，“世界您好”

字符串对象处于激活状态。

 

        当程序执行了test方法的2代码后，代码再次定义了“您好世界”字符串对象，并让a变量指向该对象，此时，“世界您好”字符串对象处于去活状态，而“您好世界”字符串对象处于激活状态。

 

       一个对象可以被一个方法局部变量所引用，也可以被其他类的类属性所引用，或被其他对象的实例属性引用，当某个对象被其了类的类属性引用时，只有该类被销毁后，该对象才会进入去活状态：当某个对象被其他对象的实例属性引用时，只有当该对象被销毁后，该对象才会进入去活状态。

 

 

       强制垃圾回收

 

程序只能控制一个对象何时不再被任何引用变量引用，绝不能控制它何时被回收。

 

强制系统垃圾回收有如下两个方法：

 

》调用System类的gc()静态方法：System.gc()

 

》调用Runtime对象的gc()实例方法：Runtime.getRuntime().gc()

 

 

下面代码创建了4个匿名对象，每个对象创建之后立即进入去活状态，等待系统回收，但直到程序退出，系统依然不会回收该资源

 

public class GcTest

{

       public static void main(String[] args)

       {

               for(int i = 0; i<4;i++)

               {

                        new TestGc();

 

                      //如果增加下面代码就不一样了

                       //下面两行代码的作用完全相同，强制系统进行垃圾回收

                       System.gc();

                        

                       Runtime.getRuntime().gc();

                }

       }

       public void finalize()

       {

                     System.out.println("系统正在清理TestGc对象的资源");

       }

}

 

运行命令：java -verbose:gc GcTest

 

看编译结果：

 

编译的结果显示了程序强制垃圾回收的效果，但这种强制仅仅只是建议系统立即垃圾回收，系统完全有可能并不立即进行垃圾回收，但垃圾回收机制也不会对程序的建议完全置之不理：垃圾回收机制会在收到通知后，尽快进行垃圾回收。

 

 

finalize 方法

 

当垃圾回收机制回收某个对象所占用的内存这前，通常要求程序调用适当的方法来清理资源，在没有明确指定资源清理的情况下，JAVA提供了默认机制来清理该对象的资源，这个方法不是finalize。

 

该方法是定义在Object类的实例方法。

 

protected void finalize() throws Thrwable

 

当finalize()方法返回后，对象消失，垃圾回收机制开始执行。后面的那句为抛出任何类型的异常。

 

 

finalize方法有如下四个特点：

》永远不要主动调用某个对象的finlize方法，该方法应交给垃圾回收机制来调用。

 

》finalize方法何时被调用，是否被调用具有不确定性，不要把finalize方法当成一定会被执行的方法

 

》当JVM执行去活对象的finalize方法时，可能使该对象或系统中其他对象重新变成激活状态。

 

》当JVM执行finalize方法时出现了异常，垃圾回收机制不会报告异常，程序继续执行。

 

 

下面代码表示了finalize方法里把自身复活，并可通过该程序看出垃圾回收的不确定性。

 

public class TestFinalize

{

        private static TestFinalize tf = null;

 

         public void info()

         {

                 System.out.println("测试资源清理的finalize方法");

         }

 

          public static void main (String[] args) throws Exception

           {

                      //创建TestFinalize对象立即进入去活状态

                      new TestFinalize()

                        

                       //通知系统进行资源回

                       System.gc();          //1

 

                       //让程序暂停2秒

                      Thread.sleep(2000);            //2

 

                       tf.info();

           }

           public void finalize()

           {

                      //让tf引用到试图回收的去活对象，即去活对象重新变成激活

                       tf = this;

           }

}

 

编译结果：

 

 

 

 

JAVA对象的软，弱和虚引用

 

对大部分对象而言，程序里会有一个引用变量引用该对象，这种引用方式是最常见的引用方式。

 

除此之外，java.lang.ref包下提供了三个类：SoftReference,PhantomReference,WeakReference.分别是软引用，虚引用和弱引用。

 

强引用是我们最常见的引用方式。

 

 

public class ReferenceTest

{

        public static void main(String[] args) throws Exception

         {

                   //创建一个字符串对象

                    String str = new String ("世界您好");

 

                    //创建一个弱引用，让此弱引用引用到“世界您好”

                     WeakReference wr = new WeakReference(str);      //1

 

                    //切断str引用和“世界您好”字符串之间的引用

                     str = null;                //2

 

                   //取出弱引用所引用的对象

                   System.out.println(wr.get());                //3

 

                   //强制垃圾回收

                   System.gc();

                   System.runFinalization();

 

                     //再次取出弱引用所引用的对象

                     System.out.println(wr.get())          //4

         }

}

 

编译结果：

 

 

 

 

 

上面代码先创建了一个“世界您好”字符串对象，并让str引用变量引用它，执行1行时，系统创建了一个弱引用对象，并让该对象和str引用同一个对象，。当程序执行到2行时，程序切断了str和“世界您好”字符串对象之音的引用关系。

 

 

图中我们看出，此时“世界您好”字符串只有一个弱引用对象引用它。此时程序依然可以通过这个弱引用对象来访问字符串常量。程序3行依然可以输出“世界您好”。

 

接下来程序强制垃圾回收，如果系统垃圾回收机制启动，只有弱引用的对象 就会被清理掉，当程序执行4行代码时，通常就会看到输出null，这表明该对象已经被清理了。

 

 

下面为虚引用

 

public class  PhantomReferenceTest

{

      public static void main(String[] args) throws Exception

      {

                   //创建一个字符串对象

                   String str = new String("世界您好");

 

                    //创建一个引用队列

                    ReferenceQueue rq = new ReferenceQueue();

 

                   //创建一个虚引用，让此虚引用到“世界您好”字符串

                   PhantomReference pr = new PhantomReference(str ,rq);

 

                  //切断str引用和“世界您好”字符串之间的引用

                  str = null;

 

                 //取出虚引用所引用的对象，并不能通过虚引用访问被引用的对象，所以此处输出null

                  System.out.println(pr.get());          

 

                 //强制垃圾回收

                  System.gc();

                 //Runtime.getRuntime.gc();

                 System.runFinalization();

 

                  //取出引用队列中最先进入队列中的引用与pr进行比较

                 System.out.println(rq.poll() == pr); 

        }

}

 

 

我们要记住：要使用这些特殊的引用类，就不能保留对对象的强引用。如果保留了对对象的强引用，那么就会浪费这些类所提供的任何好处。

 

 

 

JAVA修饰符的适用范围

 

到目前为止，我们已经学习了JAVA中大部分的修饰符，如访问控制符，static final。等。

 

我们看图就容易理解了：

 

 

 

 

这里有abstract 和final 不能同时使用，abstract 和static 不能同时使用，abstract 和private 不能同时使用。

 

在Java中，通常通讯类型的服务器对GC(Garbage Collection)比较敏感。通常通讯服务器每秒需要处理大量进出的数据包，需要解析，分解成不同的业务逻辑对象并做相关的业务处理，这样会导致大量的临时对象被创建和回收。同时服务器如果需要同时保存用户状态的话，又会产生很多永久的对象，比如用户session。业务越复杂的应用往往用户session包含的引用对象就越多。这样在极端情况下会发生两件事情，long gc pause time 或 out of memory。

一，要解决long pause time首先要了解JVM中heap的结构

java gc heap

• Java Heap为什么要分成几个不同的代(generation)? 由于80%-98%的对象的生存周期很短，大部分新对象存放在young generation可以很高效的回收，避免遍历所有对象。
• young与old中内存分配的算法完全不同。young generation中由于存活的很少，要mark, sweep 然后再 compact 剩余的对象比较耗时，干脆把 live object copy 到另外一个空间更高效。old generation完全相反，里面的 live object 变化较少。因此采用 mark-sweep-compact更合适。

二，Java中四种垃圾回收算法

Java中有四种不同的回收算法，对应的启动参数为
–XX:+UseSerialGC
–XX:+UseParallelGC
–XX:+UseParallelOldGC
–XX:+UseConcMarkSweepGC

1. Serial Collector
大部分平台或者强制 java -client 默认会使用这种。
young generation算法 = serial
old generation算法 = serial (mark-sweep-compact)
这种方法的缺点很明显，stop-the-world, 速度慢。服务器应用不推荐使用。

2. Parallel Collector
在linux x64上默认是这种，其他平台要加 java -server 参数才会默认选用这种。
young = parallel，多个thread同时copy
old = mark-sweep-compact = 1
优点：新生代回收更快。因为系统大部分时间做的gc都是新生代的，这样提高了throughput(cpu用于非gc时间)
缺点：当运行在8G/16G server上old generation live object太多时候pause time过长

3. Parallel Compact Collector (ParallelOld)
young = parallel = 2
old = parallel，分成多个独立的单元，如果单元中live object少则回收，多则跳过
优点：old old generation上性能较 parallel 方式有提高
缺点：大部分server系统old generation内存占用会达到60%-80%, 没有那么多理想的单元live object很少方便迅速回收，同时compact方面开销比起parallel并没明显减少。

4. Concurent Mark-Sweep(CMS) Collector
young generation = parallel collector = 2
old = cms
同时不做 compact 操作。
优点：pause time会降低, pause敏感但CPU有空闲的场景需要建议使用策略4.
缺点：cpu占用过多，cpu密集型服务器不适合。另外碎片太多，每个object的存储都要通过链表连续跳n个地方，空间浪费问题也会增大。

几条经验：
1. java -server
2. 设置Xms=Xmx=3/4物理内存
3. 如果是CPU密集型服务器，使用–XX:+UseParallelOldGC, 否则–XX:+UseConcMarkSweepGC
4. 新生代,Parallel/ParallelOld可设大于Xmx1/4，CMS可设小，小于Xmx1/4
5. 优化程序，特别是每个用户的session中的集合类等。我们的一个模块中session中曾经为每个用户使用了一个ConcurrentHashMap, 里面通常只有几条记录，后来改成数组之后，每台机大概节约了1~2G内存。

不过总的说来，Java的GC算法感觉是业界最成熟的，目前很多其他语言或者框架也都支持GC了，但大多数都是只达到Java Serial gc这种层面，甚至分generation都未考虑。JDK7里面针对CMS又进行了一种改进，会采用一种G1(Garbage-First Garbage Collection)的算法。实际上Garbage-First paper(PDF) 2004年已经出来了，相信到JDK7已经可以用于严格生产环境，有时间也会进一步介绍一下G1。
另外在今年的Sun Tech Days上Joey Shen讲的Improving Java Performance(PDF)也是一个很好的Java GC调优的入门教程。