Java异常处理

很多刚接触Java的人不太理解Java的异常处理的用法,搞不清楚为啥有这个东西。

其实简单点说,异常就是控制流程的转意。没有特别的地方,可以在方法的任何地方抛出异常,也可以处理异常。Java里面的异常一般用throw,try…catch关键词。

下面是一个简单的代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class T{
public void m2(){
}
public void he(Exception ex){
}
    public void m1(){
        try{
            m2();
        }catch(RuntimeException ex){
            he(ex);
        }
        catch(Exception ex){
            he(ex);
        }
    }
}

再看看这段代码的Class指令:

Compiled from "T.java"
public class T extends java.lang.Object{
public T();
  Code:
   0:	aload_0
   1:	invokespecial	#1; //Method java/lang/Object."":()V
   4:	return
 
public void m2();
  Code:
   0:	return
 
public void he(java.lang.Exception);
  Code:
   0:	return
 
public void m1();
  Code:
   0:	aload_0          //load this object....
   1:	invokevirtual	#2; //Method m2:()V  执行m2()方法
   4:	goto	22       //如果有异常就跳转。。
   7:	astore_1        //保存RuntimeException类型临时变量,异常表中会用到
   8:	aload_0         //load this object........
   9:	aload_1        //load #7的临时变量
   10:	invokevirtual	#4; //Method he:(Ljava/lang/Exception;)V
   13:	goto	22    
   16:	astore_1
   17:	aload_0
   18:	aload_1
   19:	invokevirtual	#4; //Method he:(Ljava/lang/Exception;)V
   22:	return
  Exception table:       // 异常表。
   from   to  target type
     0     4     7   Class java/lang/RuntimeException   
     0     4    16   Class java/lang/Exception
}

Java里面的异常就是控制流程的转移,没有别的东西。没有那么豪华。。。

程序中如果增加了关键词finally,指令集变得『复杂』起来。finally关键词在语言层面表示无论怎样都要被执行的意思。

还以上面的java代码为例:

public class T{
public void m2(){
}
public void he(Exception ex){
}
    public void m1(){      
        try{
            m2();
        }catch(RuntimeException ex){
            he(ex);
        }
        catch(Exception ex){
            he(ex);
        }finally{
            System.out.println("Hello");  //无论如何都打印这个字符串。
        }
    }
}

Class指令如下:

Compiled from "T.java"
public class T extends java.lang.Object{
public T();
  Code:
   0:	aload_0
   1:	invokespecial	#1; //Method java/lang/Object."":()V
   4:	return
 
public void m2();
  Code:
   0:	return
 
public void he(java.lang.Exception);
  Code:
   0:	return
 
public void m1();
  Code:
   0:	aload_0
   1:	invokevirtual	#2; //Method m2:()V
   4:	getstatic	#3; //Field java/lang/System.out:Ljava/io/PrintStream;
   7:	ldc	#4; //String Hello
   9:	invokevirtual	#5; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   12:	goto	60
   15:	astore_1
   16:	aload_0
   17:	aload_1
   18:	invokevirtual	#7; //Method he:(Ljava/lang/Exception;)V
   21:	getstatic	#3; //Field java/lang/System.out:Ljava/io/PrintStream;
   24:	ldc	#4; //String Hello
   26:	invokevirtual	#5; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   29:	goto	60
   32:	astore_1
   33:	aload_0
   34:	aload_1
   35:	invokevirtual	#7; //Method he:(Ljava/lang/Exception;)V
   38:	getstatic	#3; //Field java/lang/System.out:Ljava/io/PrintStream;
   41:	ldc	#4; //String Hello
   43:	invokevirtual	#5; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   46:	goto	60
   49:	astore_2
   50:	getstatic	#3; //Field java/lang/System.out:Ljava/io/PrintStream;
   53:	ldc	#4; //String Hello
   55:	invokevirtual	#5; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   58:	aload_2
   59:	athrow
   60:	return
  Exception table:
   from   to  target type
     0     4    15   Class java/lang/RuntimeException
 
     0     4    32   Class java/lang/Exception
 
     0     4    49   any
    15    21    49   any
    32    38    49   any
    49    50    49   any
 
}

方法m2()的字节码中0~9,15~26,32~43,49~59 分别表示了程序执行的4种可能结果。字节码变得复杂庞大。。。

JVM调优

1. Heap设定与垃圾回收
Java Heap分为3个区,Young,Old和Permanent。Young保存刚实例化的对象。当该区被填满时,GC会将对象移到Old区。Permanent区则负责保存反射对象,本文不讨论该区。
JVM的Heap分配可以使用-X参数设定,
-Xms
初始Heap大小
-Xmx
java heap最大值
-Xmn
young generation的heap大小
JVM有2个GC线程。第一个线程负责回收Heap的Young区。第二个线程在Heap不足时,遍历Heap,将Young 区升级为Older区。Older区的大小等于-Xmx减去-Xmn,不能将-Xms的值设的过大,因为第二个线程被迫运行会降低JVM的性能。
为什么一些程序频繁发生GC?有如下原因:
l         程序内调用了System.gc()或Runtime.gc()。
l         一些中间件软件调用自己的GC方法,此时需要设置参数禁止这些GC。
l         Java的Heap太小,一般默认的Heap值都很小。
l         频繁实例化对象,Release对象。此时尽量保存并重用对象,例如使用StringBuffer()和String()。
如果你发现每次GC后,Heap的剩余空间会是总空间的50%,这表示你的Heap处于健康状态。许多Server端的Java程序每次GC后最好能有65%的剩余空间。
经验之谈:
1.Server端JVM最好将-Xms和-Xmx设为相同值。为了优化GC,最好让-Xmn值约等于-Xmx的1/3[2]。
2.一个GUI程序最好是每10到20秒间运行一次GC,每次在半秒之内完成[2]。
注意:
1.增加Heap的大小虽然会降低GC的频率,但也增加了每次GC的时间。并且GC运行时,所有的用户线程将暂停,也就是GC期间,Java应用程序不做任何工作。
2.Heap大小并不决定进程的内存使用量。进程的内存使用量要大于-Xmx定义的值,因为Java为其他任务分配内存,例如每个线程的Stack等。
2.Stack的设定
每个线程都有他自己的Stack。
-Xss
每个线程的Stack大小
Stack的大小限制着线程的数量。如果Stack过大就好导致内存溢漏。-Xss参数决定Stack大小,例如-Xss1024K。如果Stack太小,也会导致Stack溢漏。
3.硬件环境
硬件环境也影响GC的效率,例如机器的种类,内存,swap空间,和CPU的数量。
如果你的程序需要频繁创建很多transient对象,会导致JVM频繁GC。这种情况你可以增加机器的内存,来减少Swap空间的使用[2]。
4.4种GC
第一种为单线程GC,也是默认的GC。,该GC适用于单CPU机器。
第二种为Throughput GC,是多线程的GC,适用于多CPU,使用大量线程的程序。第二种GC与第一种GC相似,不同在于GC在收集Young区是多线程的,但在Old区和第一种一样,仍然采用单线程。-XX:+UseParallelGC参数启动该GC。
第三种为Concurrent Low Pause GC,类似于第一种,适用于多CPU,并要求缩短因GC造成程序停滞的时间。这种GC可以在Old区的回收同时,运行应用程序。-XX:+UseConcMarkSweepGC参数启动该GC。
第四种为Incremental Low Pause GC,适用于要求缩短因GC造成程序停滞的时间。这种GC可以在Young区回收的同时,回收一部分Old区对象。-Xincgc参数启动该GC。

参考文章:
2. Performance tuning Java: Tuning steps
3. Tuning Garbage Collection with the 1.4.2 JavaTM Virtual Machine .