(一) JConsole

JConsole使用JVM的可扩展性Java管理扩展(JMX)工具来提供关于运行于Java平台的应用程序的性能和资源消耗的信息。

在J2SE 5.0软件中，你需要启动使用-Dcom.sun.management.jmxremote选项监控的应用程序。注意：在Java SE 6软件中，不再有这一要求。当启动该应用程序时，不需要特定的命令行选项。

在生产系统中的应用

JConsole启动一个在被观察的Java程序的JVM内部的JMX代理。运行另外一部分代码仅有一点极微弱的影响-但是影响很小。

另外，尽管JConsole在监视本地应用程序的开发和快速原型开发中很有用，但在实际的应用系统中不推荐使用。理由是，JConsole本身也消耗大 量的系统资源。我们推荐的方法是用远程监控来把JConsole应用程序与被监控的系统加以隔离。因此,对于应用系统来说,以远程模式使用 JConsole更好些。对于安全的远程监控来说,可以使用安全选项。

(二) jps

jps相当于Solaris进程工具ps。更多的信息，请参考《jps-Java Virtual Machine Process Status Tool》。

不象"pgrep java"或"ps -ef grep java"，jps并不使用应用程序名来查找JVM实例。因此，它查找所有的Java应用程序，包括即使没有使用java执行体的那种（例如，定制的启动 器）。另外，jps仅查找当前用户的Java进程，而不是当前系统中的所有进程。

(三) jstat

jstat 显示一个测量（instrumented）Java HotSpot虚拟机的性能统计信息（请参考《jstat-Java Virtual Machine Statistics Monitoring Tool》）。有关于性能计数器的更详细的信息请参考《Code sample-jvmstat 3.0》。

(四) jstatd

jstatd是一个Java远程方法调用 (RMI)服务器应用程序-它监控测量Java HotSpot虚拟机的创建和终止并且提供一个接口来允许远程监控工具依附到运行于本地主机的JVM（请参考《jstatd-Virtual Machine jstat Daemon》）。

在应用系统中的使用

jps及其它jvmstat实用程序都使用 极为轻量级的观察机制。由JVM分配一小部分共享内存，而性能计数器也是从这部分内存中分配的。JVM子系统基于其感兴趣的事件更新性能计数器。客户端工 具仅仅负责异步地从共享内存段中进行读取。因此，总的来说，使用jvmstat进行监控的效果是很小的。 Photoshop教程 数据结构 五笔输入法专题



Java SE 6平台中针对于Postmortem的可观察性工具

Java SE 6支持postmortem可观察性工具-它能够从挂起的Java进程或Java核心复制中获得信息。这些工具（除了jhat外）都使用Solaris libproc库来依附到和读取被观察的程序。在观察期间，目标程序被挂起。当Java进程被挂起或当从一个Java进程中发生一个核心复制时，可以使用 这些工具。在任何可能的情况下，请考虑使用gcore来捕获系统的核心复制的一个快照并且使用任何下列工具"离线"分析核心复制。

(一) jinfo

jinfo打印一个给定的Java进程或核心文件或一个远程调试服务器的Java配置信息。配置信息包括Java系统属性和JVM命令行标志(更多信息，请参考《jinfo-Configuration Info》)。

(二) jmap

jmap：如果这个工具不使用任何选项（除了pid或core选项）运行，那么它显示类似于Solaris的pmap工具所输出的信息。这个工具支持针对Java堆可观察性的若干其它选项。

在Java SE 6平台中,新加入了一个-dump选项。这样可以使jmap能够把Java堆信息复制到一个文件中，然后我们可以使用新的jhat命令（见下面一节）来分析它。

jmap -dump选项并不使用Solaris libproc来实现实时处理；而是，它运行当前正运行的JVM中的一小段代码，由此来实现堆复制。既然这种堆复制代码运行于JVM内部，那么其速度是比 较快的。堆复制的效果大致相当于实现一次"完全的GC"（对整个堆的垃圾收集），再加上把该堆的内容写入到文件中。实现堆复制的另外一种可能的思路是使用 gcore来进行核心复制并且运行"jmap -dump"（这与以"离线"方式运行的核心复制形成对照）。

(三) jstack

jstack等价于Solaris的pstack工具。jstack打印所有的Java线程的堆栈跟踪信息（可选地包括本机帧信息），请参考《jstack-堆栈跟踪》。关于锁和死锁的信息也可以被打印，请参考java.util.concurrent locks。

(四) jsadebugd

jsadebugd依附到一个Java进程或核心文件并且担当一个调试服务器的作用。远程客户，例如jstack、jmap和jinfo，都能够通过Java RMI依附到该服务器。

(五) jhat

jhat是一个Java堆复制浏览器。这个工具分析Java堆复制文件（例如，由上面的"jmap -dump"所产生的）。Jhat启动一个允许堆中的对象在web浏览器中进行分析的web服务器。这个工具并不是想用于应用系统中而是用于"离线"分 析。"jhat工具是平台独立的"，其意思是，它可以被用来观察在任何平台上所产生的堆复制。例如，我们有可能在Linux系统上使用jhat来观察一个 在Solaris OS上所产生的堆复制。

把本机的java内存映像导出到heap.dmp中,其中PID为java进程的ID号。
jmap -dump:live,format=b,file=heap.dmp PID

导出后的映像文件可以用jhat来进行分析，-J是向java虚拟机传一个参数，如-mx768m是指定虚拟机可用最大的内存为768M。如果映像文件很大，你要指定一个很大的值，否则在分析过程中就会有OutOfMemeryError的错误。
jhat -J-mx768m -port <端口号:默认为7000> heap.dmp

许多Web应用都将数据保存到RDBMS中，应用服务器从中读取数据并在浏览器中显示。但随着数据量的增大、访问的集中，就会出现RDBMS的负担加重、数据库响应恶化、网站显示延迟等重大影响。

这时就该memcached大显身手了。memcached是高性能的分布式内存缓存服务器。一般的使用目的是，通过缓存数据库查询结果，减少数据库访问次数，以提高动态Web应用的速度、提高可扩展性......
         
         完整文章下载   /Files/envoydada/memcached.pdf

         Server端下载  
                                 http://danga.com/memcached
                                 http://jehiah.cz/projects/memcached-win32/

         Client端下载   http://www.whalin.com/memcached/

2.获得GC LOG文件，使用日志查看器如HP的HPJtune，HPJmeter（均可从HP网站下载到）打开日志文件;

基本参数说明：

-client，-server
这两个参数用于设置虚拟机使用何种运行模式，client模式启动比较快，但运行时性能和内存管理效率不如server模式，通常用于客户端应用程序。相反，server模式启动比client慢，但可获得更高的运行性能。
在windows上，缺省的虚拟机类型为client模式，如果要使用server模式，就需要在启动虚拟机时加-server参数，以获得更高性能，对服务器端应用，推荐采用server模式，尤其是多个CPU的系统。在Linux，Solaris上缺省采用server模式。

-hotspot
含义与client相同，jdk1.4以前使用的参数，jdk1.4开始不再使用，代之以client。

-classpath,-cp
虚拟机在运行一个类时，需要将其装入内存，虚拟机搜索类的方式和顺序如下：

Bootstrap classes，Extension classes，User classes。

Bootstrap 中的路径是虚拟机自带的jar或zip文件，虚拟机首先搜索这些包文件，用System.getProperty("sun.boot.class.path")可得到虚拟机搜索的包名。

Extension是位于jre\lib\ext目录下的jar文件，虚拟机在搜索完Bootstrap后就搜索该目录下的jar文件。用System. getProperty("java.ext.dirs”)可得到虚拟机使用Extension搜索路径。

User classes搜索顺序为当前目录、环境变量 CLASSPATH、-classpath。

-classpath告知虚拟机搜索目录名、jar文档名、zip文档名，之间用分号;分隔。

例如当你自己开发了公共类并包装成一个common.jar包，在使用common.jar中的类时，就需要用-classpath common.jar 告诉虚拟机从common.jar中查找该类，否则虚拟机就会抛出java.lang.NoClassDefFoundError异常，表明未找到类定义。

在运行时可用System.getProperty(“java.class.path”)得到虚拟机查找类的路径。

使用-classpath后虚拟机将不再使用CLASSPATH中的类搜索路径，如果-classpath和CLASSPATH都没有设置，则虚拟机使用当前路径(.)作为类搜索路径。

推荐使用-classpath来定义虚拟机要搜索的类路径，而不要使用环境变量CLASSPATH的搜索路径，以减少多个项目同时使用CLASSPATH时存在的潜在冲突。例如应用1要使用a1.0.jar中的类G，应用2要使用a2.0.jar中的类G,a2.0.jar是a1.0.jar的升级包，当a1.0.jar，a2.0.jar都在CLASSPATH中，虚拟机搜索到第一个包中的类G时就停止搜索，如果应用1应用2的虚拟机都从CLASSPATH中搜索，就会有一个应用得不到正确版本的类G。

-D<propertyName>=value

在虚拟机的系统属性中设置属性名/值对，运行在此虚拟机之上的应用程序可用System.getProperty(“propertyName”)得到value的值。
如果value中有空格，则需要用双引号将该值括起来，如-Dname=”space string”。
该参数通常用于设置系统级全局变量值，如配置文件路径，应为该属性在程序中任何地方都可访问。

-verbose[:class|gc|jni]

在输出设备上显示虚拟机运行信息。
verbose和verbose:class含义相同，输出虚拟机装入的类的信息，显示的信息格式如下：
[Loaded java.io.FilePermission$1 from shared objects file]
当虚拟机报告类找不到或类冲突时可用此参数来诊断来查看虚拟机从装入类的情况。

-verbose:gc在虚拟机发生内存回收时在输出设备显示信息，格式如下：
[Full GC 268K->168K(1984K), 0.0187390 secs]
该参数用来监视虚拟机内存回收的情况。

-verbose:jni在虚拟机调用native方法时输出设备显示信息，格式如下：
[Dynamic-linking native method HelloNative.sum ... JNI]
该参数用来监视虚拟机调用本地方法的情况，在发生jni错误时可为诊断提供便利。

-version
显示可运行的虚拟机版本信息然后退出。一台机器上装有不同版本的JDK时

-showversion
显示版本信息以及帮助信息。

-ea[:<packagename>...|:<classname>]
-enableassertions[:<packagename>...|:<classname>]
从JDK1.4开始，java可支持断言机制，用于诊断运行时问题。通常在测试阶段使断言有效，在正式运行时不需要运行断言。断言后的表达式的值是一个逻辑值，为true时断言不运行，为false时断言运行，抛出java.lang.AssertionError错误。
上述参数就用来设置虚拟机是否启动断言机制，缺省时虚拟机关闭断言机制，用-ea可打开断言机制，不加<packagename>和classname时运行所有包和类中的断言，如果希望只运行某些包或类中的断言，可将包名或类名加到-ea之后。例如要启动包com.foo.util中的断言，可用命令 –ea:com.foo.util 。

-da[:<packagename>...|:<classname>]
-disableassertions[:<packagename>...|:<classname>]
用来设置虚拟机关闭断言处理，packagename和classname的使用方法和-ea相同。

-esa | -enablesystemassertions
设置虚拟机显示系统类的断言。

-dsa | -disablesystemassertions
设置虚拟机关闭系统类的断言。

-agentlib:<libname>[=<options>]
该参数是JDK5新引入的，用于虚拟机装载本地代理库。

Libname为本地代理库文件名，虚拟机的搜索路径为环境变量PATH中的路径，options为传给本地库启动时的参数，多个参数之间用逗号分隔。在Windows平台上虚拟机搜索本地库名为libname.dll的文件，在Unix上虚拟机搜索本地库名为libname.so的文件，搜索路径环境变量在不同系统上有所不同，Linux、SunOS、IRIX上为LD_LIBRARY_PATH，AIX上为LIBPATH，HP-UX上为SHLIB_PATH。

例如可使用-agentlib:hprof来获取虚拟机的运行情况，包括CPU、内存、线程等的运行数据，并可输出到指定文件中，可用-agentlib:hprof=help来得到使用帮助列表。在jre\bin目录下可发现hprof.dll文件。

-agentpath:<pathname>[=<options>]
设置虚拟机按全路径装载本地库，不再搜索PATH中的路径。其他功能和agentlib相同。

-javaagent:<jarpath>[=<options>]
虚拟机启动时装入java语言设备代理。Jarpath文件中的mainfest文件必须有Agent-Class属性。代理类要实现public static void premain(String agentArgs, Instrumentation inst)方法。当虚拟机初始化时，将按代理类的说明顺序调用premain方法。
参见：java.lang.instrument

扩展参数说明
-Xmixed
设置-client模式虚拟机对使用频率高的方式进行Just-In-Time编译和执行，对其他方法使用解释方式执行。该方式是虚拟机缺省模式。

-Xint
设置-client模式下运行的虚拟机以解释方式执行类的字节码，不将字节码编译为本机码。

-Xbootclasspath:path

-Xbootclasspath/a:path

-Xbootclasspath/p:path
改变虚拟机装载缺省系统运行包rt.jar而从-Xbootclasspath中设定的搜索路径中装载系统运行类。除非你自己能写一个运行时，否则不会用到该参数。
/a:将在缺省搜索路径后加上path 中的搜索路径。
/p:在缺省搜索路径前先搜索path中的搜索路径。

-Xnoclassgc
关闭虚拟机对class的垃圾回收功能。

-Xincgc
启动增量垃圾收集器，缺省是关闭的。增量垃圾收集器能减少偶然发生的长时间的垃圾回收造成的暂停时间。但增量垃圾收集器和应用程序并发执行，因此会占用部分CPU在应用程序上的功能。

-Xloggc:<file>
将虚拟机每次垃圾回收的信息写到日志文件中，文件名由file指定，文件格式是平文件，内容和-verbose:gc输出内容相同。

-Xbatch
虚拟机的缺省运行方式是在后台编译类代码，然后在前台执行代码，使用-Xbatch参数将关闭虚拟机后台编译，在前台编译完成后再执行。

-Xms<size>
设置虚拟机可用内存堆的初始大小，缺省单位为字节，该大小为1024的整数倍并且要大于1MB，可用k(K)或m(M)为单位来设置较大的内存数。初始堆大小为2MB。
例如：-Xms6400K，-Xms256M

-Xmx<size>
设置虚拟机内存堆的最大可用大小，缺省单位为字节。该值必须为1024整数倍，并且要大于2MB。可用k(K)或m(M)为单位来设置较大的内存数。缺省堆最大值为64MB。
例如：-Xmx81920K，-Xmx80M
当应用程序申请了大内存运行时虚拟机抛出java.lang.OutOfMemoryError: Java heap space错误，就需要使用-Xmx设置较大的可用内存堆。

-Xss<size>
设置线程栈的大小，缺省单位为字节。与-Xmx类似，也可用K或M来设置较大的值。通常操作系统分配给线程栈的缺省大小为1MB。
另外也可在java中创建线程对象时设置栈的大小，构造函数原型为Thread(ThreadGroup group, Runnable target, String name, long stackSize)。

-Xprof
输出CPU运行时的诊断信息。

-Xfuture
对类文件进行严格格式检查，以保证类代码符合类代码规范。为保持向后兼容，虚拟机缺省不进行严格的格式检查。

-Xrs
减少虚拟机中操作系统的信号（singals）的使用。该参数通常用在虚拟机以后台服务方式运行时使用（如Servlet）。

-Xcheck:jni
调用JNI函数时进行附加的检查，特别地虚拟机将校验传递给JNI函数参数的合法性，在本地代码中遇到非法数据时，虚拟机将报一个致命错误而终止。使用该参数后将造成性能下降。

Written by Halatu Hubisi

约定:
1.读者应具备一定JAVA的知识.

2.本文中的JVM选项均以SUN公司发布的HotSpot JVM 5为准（不过大多数的选项在JVM1.3,JVM1.4中也是可用的）.

3.以JAVA_HOME下demo/jfc/SwingSet2/SwingSet2.jar为例进行说明.

4.阅读本文需要一些关于GC的知识，可以到附录A中了解这些知识。

关键字:
JVM(java虚拟机),调优,GC(垃圾回收)

JVM GC调优
为了能够将JVM GC的调优能够使用在具体的实践当中,下面将利用若干个例子来说明GC的调优.
例1：Heap size 设置
JVM堆的设置是指java程序运行过程中JVM可以调配使用的内存空间的设置.JVM在启动的时候会自动设置Heap size的值，其初始空间(即-Xms)是物理内存的1/64，最大空间(-Xmx)是物理内存的1/4。可以利用JVM提供的-Xmn -Xms -Xmx等选项可进行设置。Heap size 的大小是Young Generation 和Tenured Generaion 之和。
当在JAVA_HOME下demo/jfc/SwingSet2/目录下执行下面的命令。
java -jar -Xmn4m -Xms16m -Xmx16m SwingSet2.jar
系统输出为：

除了这些异常信息外，还会发现程序的响应速度变慢了。这说明Heap size 设置偏小，GC占用了更多的时间，而应用分配到的执行时间较少。
提示：在JVM中如果98％的时间是用于GC且可用的Heap size 不足2％的时候将抛出此异常信息。
将上面的命令换成以下命令执行则应用能够正常使用，且未抛出任何异常。
java -jar -Xmn4m -Xms16m -Xmx32m SwingSet2.jar
提示：Heap Size 最大不要超过可用物理内存的80％，一般的要将-Xms和-Xmx选项设置为相同，而-Xmn为1/4的-Xmx值。

例2：Young Generation（-Xmn）的设置
在本例中看一下Young Generation的设置不同将有什么现象发生。
假设将Young generation 的大小设置为4M ，即执行java -jar -verbose:gc -Xmn4m -Xms32m -Xmx32m -XX:+PrintGCDetails SwingSet2.jar，屏幕输出如下（节选）

将程序体制并将Young Generation的大小设置为8M，即执行java -jar -verbose:gc -Xmn8m -Xms32m -Xmx32m -XX:+PrintGCDetails SwingSet2.jar，屏幕输出如下（节选）

那么根据GC输出的信息（这里取第一行）做一下Minor收集的比较。可以看出两次的Minor收集分别在Young generation中找回3904K（3968K->64K）和7616K(7808K->192K)而对于整个jvm则找回1943K（3968K->2025）和5451K（7808K->2357K）。第一种情况下Minor收集了大约50％（1943/3904）的对象，而另外的50％的对象则被移到了tenured generation。在第二中情况下Minor收集了大约72％的对象，只有不到30％的对象被移到了Tenured Generation.这个例子说明此应用在的Young generation 设置为4m时显的偏小。
提示：一般的Young Generation的大小是整个Heap size的1/4。Young generation的minor收集率应一般在70％以上。当然在实际的应用中需要根据具体情况进行调整。

例3：Young Generation对应用响应的影响
还是使用-Xmn4m 和-Xmn8m进行比较，先执行下面的命令

java -jar -verbose:gc -Xmn4m -Xms32m -Xmx32m -XX:+PrintGCDetails -XX:+PrintGCApplicationConcurrentTime -XX:+PrintGCApplicationStoppedTime SwingSet2.jar
屏幕输出如下（节选）

Young Generation 的Minor收集占用的时间可以计算如下：应用线程被中断的总时常/（应用执行总时?L+应用线程被中断的总时常），那么在本例中垃圾收集占用的时?L约为系统的5％~14％。那么当垃圾收集占用的时间的比例越大的时候，系统的响应将越慢。
提示：对于互联网应用系统的响应稍微慢一些，用户是可以接受的，但是对于GUI类型的应用响应速度慢将会给用户带来非常不好的体验。

例4：如何决定Tenured Generation 的大小
分别以-Xmn8m -Xmx32m和-Xmn8m -Xmx64m进行对比，先执行
java -verbose:gc -Xmn8m -Xmx32m-XX:+PririntGCDetails -XX:+PrintGCTimeStamps java类，命令行将提示（只提取了Major收集）

再执行java -verbose:gc -Xmn8m -Xmx64m-XX:+PririntGCDetails -XX:+PrintGCTimeStamps java类，命令行将提示（只提取了Major收集）

可以看出在Heap size 为32m的时候系统等候时间约为0.13秒左右，而设置为64m的时候等候时间则增大到0.22秒左右了。但是在32m的时候系统的Major收集间隔为10秒左右，而Heap size 增加到64m的时候为30秒。那么应用在运行的时候是选择32m还是64m呢？如果应用是web类型（即要求有大的吞吐量）的应用则使用64m（即heapsize大一些）的比较好。对于要求实时响应要求较高的场合（例如GUI型的应用）则使用32m比较好一些。
注意：
1。因为在JVM5运行时已经对Heap-size进行了优化，所以在能确定java应用运行时不会超过默认的Heap size的情况下建议不要对这些值进行修改。
2。Heap size的 -Xms -Xmn 设置不要超出物理内存的大小。否则会提示“Error occurred during initialization of VM Could not reserve enough space for object heap”。

例5:如何缩短minor收集的时间
下面比较一下采用-XX:+UseParNewGC选项和不采用它的时候的minor收集将有什么不同。先执行
java -jar -server -verbose:gc -Xmn8m -Xms32m -Xmx32m SwingSet2.jar
系统将输出如下信息（片段〕

之后再执行 java -jar -server -verbose:gc -XX:+UseParNewGC -Xmn8m -Xms32m -Xmx32m SwingSet2.jar
系统将输出如下信息（片段〕

很显然使用了-XX:+UseParNewGC选项的minor收集的时间要比不使用的时候优。

例6:如何缩短major收集的时间
下面比较一下采用-XX:+UseConcMarkSweepGC选项和不采用它的时候的major收集将有什么不同。先执行
java -jar -verbose:gc -XX:+UseConcMarkSweepGC -XX:+UseParNewGC -Xmn64m -Xms256m -Xmx256m SwingSet2.jar
系统将输出如下信息（片段〕

之后再执行 java -jar -verbose:gc -XX:+UseParNewGC -Xmn64m -Xms256m -Xmx256m SwingSet2.jar
系统将输出如下信息（片段〕
[Full GC 56048K->18869K(260224K), 0.3104852 secs]
提示：此选项在Heap Size 比较大而且Major收集时间较长的情况下使用更合适。

例7:关于-server选项 在JVM中将运行中的类认定为server-class的时候使用此选项。SUN 的Hot Spot JVM5 如果判断到系统的配置满足如下条件则自动将运行的类认定为server-class，并且会自动设置jvm的选项（当没有手工设置这选项的时候〕而且HOTSPOT JVM5提供了自动调优的功能，他会根据JVM的运行情况进行调整。如果没有特别的需要是不需要太多的人工干预的。SUN形象的称这个机制为“人体工学”（Ergonomics〕。具体可以参考http://java.sun.com/docs/hotspot/gc5.0/ergo5.html
*.具有2个或更多个物理的处理器
*.具有2G或者更多的物理内存
提示：此选项要放在所有选项的前面。例如：java -server 其他选项 java类

附录A:预备知识
．JVM中对象的划分及管理

JVM根据运行于其中的对象的生存时间大致的分为3种。并且将这3种不同的对象分别存放在JVM从系统分配到的不同的内存空间。这种对象存放空间的管理方式叫做Generation管理方式。
1。Young Generation：用于存放“早逝”对象（即瞬时对象）。例如：在创建对象时或者调用方法时使用的临时对象或局部变量。
2。Tenured Generation：用于存放“驻留”对象（即较长时间被引用的对象）。往往体现为一个大型程序中的全局对象或长时间被使用的对象。
3。Perm Generation：用于存放“永久”对象。这些对象管理着运行于JVM中的类和方法。

．JVM选项的分类

JVM有这么几种选项供使用.
1.供-X选项使用的项目,又称为非标准选项，不同厂商的此类型选项是有所不同的。例如：IBM的JVM用的一些选项在Sun的JVM中就不一定能生效。这种选项的使用方式如下:
java -Xmn16m -Xms64m -Xmx64m java类名
2.供-XX选项使用的项目，这种类型的选项可能要求有对系统信息访问的权限。所以要慎用。这种选项的使用方式如下:
java -XX:MaxHeapFreeRatio=70 -XX:+PrintGCDetails java类名
3.java选项(即在命令行执行java后提示的选项).
java -server -verbose:gc -d64 java类名

．垃圾收集分类

在JVM中有两种垃圾方式，一种叫做Minor（次收集），另一种叫做Major（主收集）。其中Minor在Young Generation的空间被对象全部占用后执行，主要是对Young Generation中的对象进行垃圾收集。而Major是针对于整个Heap size的垃圾收集。其中Minor方式的收集经常发生，并且Minor收集所占用的系统时间小。Major方式的垃圾收集则是一种“昂贵”的垃圾收集方式，因为在Major要对整个Heap size进行垃圾收集,这会使得应用停顿的时间变得较长。

．GC信息的格式

[GC [<collector>: <starting occupancy1> -> <ending occupancy1>, <pause time1> secs] <starting occupancy3> -> <ending occupancy3>, <pause time3> secs]
<collector> GC为minor收集过程中使用的垃圾收集器起的内部名称.
<starting occupancy1> young generation 在进行垃圾收集前被对象使用的存储空间.
<ending occupancy1> young generation 在进行垃圾收集后被对象使用的存储空间
<pause time1> minor收集使应用暂停的时间长短(秒)
<starting occupancy3> 整个堆(Heap Size)在进行垃圾收集前被对象使用的存储空间
<ending occupancy3> 整个堆(Heap Size)在进行垃圾收集后被对象使用的存储空间
<pause time3> 整个垃圾收集使应用暂停的时间长短(秒),包括major收集使应用暂停的时间(如果发生了major收集).
．GC信息的选项
-XX:+PrintGCDetails 显示GC的详细信息
-XX:+PrintGCApplicationConcurrentTime 打印应用执行的时间
-XX:+PrintGCApplicationStoppedTime 打印应用被暂停的时间
提示:1.":"后的"+"号表示开启此选项,如果是"-"号那么表示关闭此选项。
     2.在不同的选项和不同的收集方式和类型下输出的格式会有所不同。

附录B：HotSpot JVM 选项
请参考JavaTM HotSpot VM Options

附录C：其他资源
http://java.sun.com/docs/hotspot/gc5.0/gc_tuning_5.html
http://java.sun.com/docs/hotspot/gc5.0/ergo5.html

这个查询指定了:

SQL查询字符串

查询返回的实体

这里，结果集字段名被假设为与映射文件中指明的字段名相同。对于连接了多个表的查询，这就可能造成问题，因为可能在多个表中出现同样名字的字段。下面的方法就可以避免字段名重复的问题:

这个查询指定了:

SQL查询语句，它带一个占位符，可以让Hibernate使用字段的别名.

查询返回的实体，和它的SQL表的别名.

addEntity()方法将SQL表的别名和实体类联系起来，并且确定查询结果集的形态。

addJoin()方法可以被用于载入其他的实体和集合的关联.

原生的SQL查询可能返回一个简单的标量值或者一个标量和实体的结合体。

除此之外，你还可以在你的hbm文件中描述结果集映射信息，在查询中使用。

命名SQL查询
可以在映射文档中定义查询的名字,然后就可以象调用一个命名的HQL查询一样直接调用命名SQL查询.在这种情况下,我们不 需要调用addEntity()方法.

找到这样一段：

echo "Using CATALINA_BASE: $CATALINA_BASE"

echo "Using CATALINA_HOME: $CATALINA_HOME"

echo "Using CATALINA_TMPDIR: $CATALINA_TMPDIR"

echo "Using JAVA_HOME: $JAVA_HOME"

在其后加上:
CATALINA_OPTS="$CATALINA_OPTS -Xms128m -Xmx256m -XX:MaxNewSize=256m -XX:MaxPermSize=256m $JPDA_OPTS"

JAVA_OPTS="$JAVA_OPTS -Djava.awt.headless=true"

echo "Using CATALINA_OPTS: $CATALINA_OPTS"

echo "Using JAVA_OPTS: $JAVA_OPTS"
_________________________________________________________

windows下就是.bat

linux下就是.sh

(必须密码一致，因此直接回车)
然后再把userhome(例如：C:\Documents and Settings\Administrator\)下的.keystore复制到tomcat的conf\目录下。

2.修改Tomcat的 server.xml文件

对于不同的数据库存取需求，我们使用JDBC来解决这个问题，对于不同的数据连接来源需求，Spring则提供了DataSource注入，更换数据来源只要在Bean定义文件中修改配置，而不用修改任何一行程序。

因应不同的系统，应用程序可能使用不同的数据来源，但如纯綷的使用 JDBC、透过连接池、或是透过JNDI等等，数据来源的更动是底层的行为，不应影响到上层的业务逻辑，为此，您可以在需要取得连接来源的Bean上保留一个数据来源注入的接口，让依赖的数据来源由该接口注入。例如我们来写一个简单的Bean：

DataBean.java

这是一个简单的测试Spring DataSource注入的程序，我们透过javax.sql.DataSource接口来注入数据来源，Spring提供了 org.springframework.jdbc.datasource.DriverManagerDataSource来取得 DataSource，它实作了javax.sql.DataSource，您将之当作一个Bean，之后再注入DataBean中即可，Bean定义档可以这么撰写：

如果您之前只使用spring-core.jar这个类别库，您还必须加入 spring-dao.jar， org.springframework.jdbc.datasource.DriverManagerDataSource是包括在这个类别库中，如果您使用的是spring.jar，当中已经包括了，无需加入任何的jar，当然，为了使用JDBC，您必须要有JDBC驱动程序的jar檔。

可以用下面这段程序简单的测试一下：

BeanDefinitionRegistry reg = new DefaultListableBeanFactory();

XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(reg);

reader.loadBeanDefinitions(new ClassPathResource("bean.xml"));;

BeanFactory bf = (BeanFactory) reg;

DataBean dataBean = (DataBean) bf.getBean("dataBean");

dataBean.testDataSource();

DriverManagerDataSource并没有提供连接池的功能，只能作作简单的单机连接测试，现在假设连接测试没有问题了，您想要换上DBCP以获得连接池的功能，则原程序不用更动，只要改改Bean定义档就可以了：

现在我们使用的是org.apache.commons.dbcp.BasicDataSource作为注入的 DataSource源，为了使用DBCP的功能，您必须要将commons-dbcp.jar加入CLASSPATH中，另外您还需要commons- pool.jar与commons-collections.jar，这些都可以在Spring的相依版本中的lib目录下找到。

注意到我们在dataSource Bean上宣告了destroy-method，如此可以确保BeanFactory在关闭时也一并关闭BasicDataSource。

如果您要直接使用JDBC来进行数据存储，使用org.springframework.jdbc.datasource.DataSourceUtils来取得Connection会是更好的方式：

Connection conn = DataSourceUtils.getConnection(dataSource);

这样作的好处是，所有的SQLException都被Spring的DataAccessException子类CannotGetJdbcConnectionException包装起来。您可以获得更多的信息，并保证存储层的可移值性。

关闭Connection时，可以用下面的方式：

DataSourceUtils.closeConnectionIfNecessry(connection, dataSource);

如果您的Servlet容器提供了JNDI资料源，您也可以简单的换上这个数据源：

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >
<hibernate-mapping package="hbm">
 <class name="EmylinkUpcode" table="emylink_upcode">
  <id
   name="id" type="integer" column="plink_code"
  >
   <generator class="org.hibernate.id.IncrementGenerator"/>
  </id>

  <property
   name="account"
   column="account"
   type="string"
   not-null="true"
   length="20"
  />
  <property
   name="plinkName"
   column="plink_name"
   type="string"
   not-null="true"
   length="50"
  />
  <property
   name="plinkExplain"
   column="plink_explain"
   type="string"
   not-null="false"
   length="100"
  />
  <property
   name="typeCode"
   column="type_code"
   type="string"
   not-null="false"
   length="8"
  />
 
  <set name="emylinkUlinks" inverse="true" lazy="true"  cascade="all"> 
       <key column="plink_code"/>
      <one-to-many class="EmylinkUlink"/>
  </set>

 </class> 
</hibernate-mapping>

操作级联（cascade）关系。
可选值：
all : 所有情况下均进行级联操作。
none：所有情况下均不进行级联操作。
save-update:在执行save-update时
进行级联操作。
delete：在执行delete时进行级联操作。

//略
    // primary key
    private java.lang.Integer id;

    // fields
    private java.lang.String account;
    private java.lang.String plinkName;
    private java.lang.String plinkExplain;
    private java.lang.String typeCode;

    // collections
    private java.util.Set<hbm.EmylinkUlink> emylinkUlinks;

//略

//略
private int hashCode = Integer.MIN_VALUE;

    // primary key
    private java.lang.Integer id;

    // fields
    private java.lang.String account;
    private java.lang.String link;
    private java.lang.String linkName;
    private java.lang.String explain;
    private java.util.Date indate;
    private java.lang.String sort;
    private java.lang.String m_private;

    // many to one
    private hbm.EmylinkUpcode plinkCode;
//略

* 延迟加载   
   如果lazy=true(延迟加载), 加载EmylinkUpcode时,hibernate不会立即加载EmylinkUlink,只有当(Iterator<EmylinkUlink> it = ul.iterator();)执行时,hibernate才加载EmylinkUlink实例; 如果在加载前就关闭session,则报异常LazyInitializationException ; 可以使用Hibernate.initialize(Object o)强制及联加载

*J2SE5.0的泛型

emylinkUlinks集合中只能存放EmylinkUlink对象，从集合中获取对象无需再类型转换
 
struts+spring+hibernate关于hibernate中lazy="true"的问题。web.xml中用   

  它的原理就是：打开页面的时候打开session，一直到页面装载完毕才关闭session，这样就解决了lazy="true"时session   is   closed的问题。
  关于OpenSessionInViewFilter 延迟加载失效问题 http://www.javaeye.com/topic/15057
          OpenSessionInView的效率问题  http://www.javaeye.com/topic/17501

1. EL脚本语言的配置和支持：
   对于一个单个JSP页面，你可以使用定义page指令来设置jsp页面是否支持EL。默认是支持EL(如果要页面不支持EL，请设置为isELIgnored=true;

1. 对于整个JSP应用程序，要修改WEB.XML配置(tomcat5.0.16默认是支持EL的);
2. <jsp-property-group> 
   <description> For config the ICW sample application </description>
   <display-name>JSPConfiguration</display-name>
   <url-pattern>/jsp/datareset.jsp</url-pattern>
   <el-ignored>true< / el-ignored>
   <page-encoding>ISO-8859-1</page-encoding>
   <scripting-invalid>true</scripting-invalid>
   <include-prelude>/jsp/prelude.jspf</include-prelude>
   <include-coda>/jsp/coda.jspf</include-coda>
   </jsp-property-group>

eg:      ${empty(requestScope.backpath)?'admin_TcAction.do?method=findFinish':requestScope.backpath}

CleanupFailureDataAccessException：清除失败异常

DataAccessResourceFailureException：资源访问异常

DataIntegrityViolationException：完整性约束异常

DataRetrievalFailureException：数据获取异常

DeadlockLoserDataAccessException：死锁访问异常

IncorrectUpdateSemanticsDataAccessException：更新出错异常

InvalidDataAccessApiUsageException：无效数据访问API使用异常

InvalidDataAccessResourceUsageException：无效数据访问资源使用异常

OptimisticLockingFailureException：乐观锁失败异常

TypeMismatchDataAccessException：类型匹配失败异常

一个cron表达式有至少6个（也可能7个）有空格分隔的时间元素。
按顺序依次为
1.秒（0~59）
2.分钟（0~59）
3.小时（0~23）
4.天（月）（0~31，但是你需要考虑你月的天数）
5.月（0~11）
6.天（星期）（1~7 1=SUN 或 SUN，MON，TUE，WED，THU，FRI，SAT）
7.年份（1970－2099）

其中每个元素可以是一个值(如6),一个连续区间(9-12),一个间隔时间(8-18/4)(/表示每隔4小时),一个列表(1,3,5),通配符。
由于"月份中的日期"和"星期中的日期"这两个元素互斥的,必须要对其中一个设置?.

0 0 10,14,16 * * ? 每天上午10点，下午2点，4点
0 0/30 9-17 * * ??? 朝九晚五工作时间内每半小时
0 0 12 ? * WED 表示每个星期三中午12点

有些子表达式能包含一些范围或列表
例如：子表达式（天（星期））可以为 “MON-FRI”，“MON，WED，FRI”，“MON-WED,SAT”

“*”字符代表所有可能的值
因此，“*”在子表达式（月）里表示每个月的含义，“*”在子表达式（天（星期））表示星期的每一天

“/”字符用来指定数值的增量
例如：在子表达式（分钟）里的“0/15”表示从第0分钟开始，每15分钟 ;
在子表达式（分钟）里的“3/20”表示从第3分钟开始，每20分钟（它和“3，23，43”）的含义一样

“？”字符仅被用于天（月）和天（星期）两个子表达式，表示不指定值
当2个子表达式其中之一被指定了值以后，为了避免冲突，需要将另一个子表达式的值设为“？”

“L” 字符仅被用于天（月）和天（星期）两个子表达式，它是单词“last”的缩写

但是它在两个子表达式里的含义是不同的。

在天（月）子表达式中，“L”表示一个月的最后一天 ,
在天（星期）自表达式中，“L”表示一个星期的最后一天，也就是SAT

如果在“L”前有具体的内容，它就具有其他的含义了

例如：“6L”表示这个月的倒数第６天，“ＦＲＩＬ”表示这个月的最后一个星期五

注意：在使用“L”参数时，不要指定列表或范围，因为这会导致问题

按如下语句执行：
java DumpMethods java.util.Stack

它的结果输出为：
public java.lang.Object java.util.Stack.push(java.lang.Object)
public synchronized java.lang.Object java.util.Stack.pop()
public synchronized java.lang.Object java.util.Stack.peek()
public boolean java.util.Stack.empty()
public synchronized int java.util.Stack.search(java.lang.Object)

这样就列出了java.util.Stack 类的各方法名以及它们的限制符和返回类型。

这个程序使用 Class.forName 载入指定的类，然后调用 getDeclaredMethods 来获取这个类中定义了的方法列表。java.lang.reflect.Methods 是用来描述某个类中单个方法的一个类。

2.开始使用 Reflection
用于 reflection 的类，如 Method，可以在 java.lang.relfect 包中找到。使用这些类的时候必须要遵循三个步骤：第一步是获得你想操作的类的 java.lang.Class 对象。在运行中的 Java 程序中，用 java.lang.Class 类来描述类和接口等。

下面就是获得一个 Class 对象的方法之一：
Class c = Class.forName("java.lang.String");
这条语句得到一个 String 类的类对象。还有另一种方法，如下面的语句：
Class c = int.class;   或者   Class c = Integer.TYPE;

它们可获得基本类型的类信息。其中后一种方法中访问的是基本类型的封装类 (如 Integer) 中预先定义好的 TYPE 字段。

第二步是调用诸如 getDeclaredMethods 的方法，以取得该类中定义的所有方法的列表。

一旦取得这个信息，就可以进行第三步了——使用 reflection API 来操作这些信息，如下面这段代码：
Class c = Class.forName("java.lang.String");
Method m[] = c.getDeclaredMethods();
System.out.println(m[0].toString());
它将以文本方式打印出 String 中定义的第一个方法的原型。
在下面的例子中，这三个步骤将为使用 reflection 处理特殊应用程序提供例证。

模拟 instanceof 操作符
得到类信息之后，通常下一个步骤就是解决关于 Class 对象的一些基本的问题。例如，Class.isInstance 方法可以用于模拟 instanceof 操作符：
class A {
}

public class instance1 {
    public static void main(String args[]) {
        try {
            Class cls = Class.forName("A");
            boolean b1 = cls.isInstance(new Integer(37));
            System.out.println(b1);
            boolean b2 = cls.isInstance(new A());
            System.out.println(b2);
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}

在这个例子中创建了一个 A 类的 Class 对象，然后检查一些对象是否是 A 的实例。Integer(37) 不是，但 new A() 是。

3.找出类的方法
找出一个类中定义了些什么方法，这是一个非常有价值也非常基础的 reflection 用法。下面的代码就实现了这一用法：
import java.lang.reflect.*;
public class method1 {
    private int f1(Object p, int x) throws NullPointerException {
        if (p == null)
            throw new NullPointerException();
        return x;
    }
    public static void main(String args[]) {
        try {
            Class cls = Class.forName("method1");
            Method methlist[] = cls.getDeclaredMethods();
            for (int i = 0; i < methlist.length; i++) {
                Method m = methlist[i];
                System.out.println("name = " + m.getName());
                System.out.println("decl class = " + m.getDeclaringClass());
                Class pvec[] = m.getParameterTypes();
                for (int j = 0; j < pvec.length; j++)
                    System.out.println("param #" + j + " " + pvec[j]);
                Class evec[] = m.getExceptionTypes();
                for (int j = 0; j < evec.length; j++)
                    System.out.println("exc #" + j + " " + evec[j]);
                System.out.println("return type = " + m.getReturnType());
                System.out.println("-----");
            }
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}

这个程序首先取得 method1 类的描述，然后调用 getDeclaredMethods 来获取一系列的 Method 对象，它们分别描述了定义在类中的每一个方法，包括 public 方法、protected 方法、package 方法和 private 方法等。如果你在程序中使用 getMethods 来代替 getDeclaredMethods，你还能获得继承来的各个方法的信息。

取得了 Method 对象列表之后，要显示这些方法的参数类型、异常类型和返回值类型等就不难了。这些类型是基本类型还是类类型，都可以由描述类的对象按顺序给出。

输出的结果如下：
name = f1
decl class = class method1
param #0 class java.lang.Object
param #1 int
exc #0 class java.lang.NullPointerException
return type = int
-----
name = main
decl class = class method1
param #0 class [Ljava.lang.String;
return type = void
-----

4.获取构造器信息
获取类构造器的用法与上述获取方法的用法类似，如：
import java.lang.reflect.*;
public class constructor1 {
    public constructor1() {
    }

    protected constructor1(int i, double d) {
    }

    public static void main(String args[]) {
        try {
            Class cls = Class.forName("constructor1");
            Constructor ctorlist[] = cls.getDeclaredConstructors();
            for (int i = 0; i < ctorlist.length; i++) {
                Constructor ct = ctorlist[i];
                System.out.println("name = " + ct.getName());
                System.out.println("decl class = " + ct.getDeclaringClass());
                Class pvec[] = ct.getParameterTypes();
                for (int j = 0; j < pvec.length; j++)
                    System.out.println("param #" + j + " " + pvec[j]);
                Class evec[] = ct.getExceptionTypes();
                for (int j = 0; j < evec.length; j++)
                    System.out.println("exc #" + j + " " + evec[j]);
                System.out.println("-----");
            }
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}

这个例子中没能获得返回类型的相关信息，那是因为构造器没有返回类型。
这个程序运行的结果是：
name = constructor1
decl class = class constructor1
-----
name = constructor1
decl class = class constructor1
param #0 int
param #1 double
-----

5.获取类的字段(域)
找出一个类中定义了哪些数据字段也是可能的，下面的代码就在干这个事情：
import java.lang.reflect.*;

public class field1 {
    private double d;
    public static final int i = 37;
    String s = "testing";

     public static void main(String args[]) {
        try {
            Class cls = Class.forName("field1");
            Field fieldlist[] = cls.getDeclaredFields();
            for (int i = 0; i < fieldlist.length; i++) {
                Field fld = fieldlist[i];
                System.out.println("name = " + fld.getName());
                System.out.println("decl class = " + fld.getDeclaringClass());
                System.out.println("type = " + fld.getType());
                int mod = fld.getModifiers();
                System.out.println("modifiers = " + Modifier.toString(mod));
                System.out.println("-----");
            }
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}

这个例子和前面那个例子非常相似。例中使用了一个新东西 Modifier，它也是一个 reflection 类，用来描述字段成员的修饰语，如“private int”。这些修饰语自身由整数描述，而且使用 Modifier.toString 来返回以“官方”顺序排列的字符串描述 (如“static”在“final”之前)。这个程序的输出是：
name = d
decl class = class field1
type = double
modifiers = private
-----
name = i
decl class = class field1
type = int
modifiers = public static final
-----
name = s
decl class = class field1
type = class java.lang.String
modifiers =
-----

和获取方法的情况一下，获取字段的时候也可以只取得在当前类中申明了的字段信息 (getDeclaredFields)，或者也可以取得父类中定义的字段 (getFields) 。

6.根据方法的名称来执行方法
文本到这里，所举的例子无一例外都与如何获取类的信息有关。我们也可以用 reflection 来做一些其它的事情，比如执行一个指定了名称的方法。下面的示例演示了这一操作：
import java.lang.reflect.*;
public class method2 {
    public int add(int a, int b) {
        return a + b;
    }
    public static void main(String args[]) {
        try {
            Class cls = Class.forName("method2");
            Class partypes[] = new Class[2];
            partypes[0] = Integer.TYPE;
            partypes[1] = Integer.TYPE;
            Method meth = cls.getMethod("add", partypes);
            method2 methobj = new method2();
            Object arglist[] = new Object[2];
            arglist[0] = new Integer(37);
            arglist[1] = new Integer(47);
            Object retobj = meth.invoke(methobj, arglist);
            Integer retval = (Integer) retobj;
            System.out.println(retval.intValue());
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}

假如一个程序在执行的某处的时候才知道需要执行某个方法，这个方法的名称是在程序的运行过程中指定的 (例如，JavaBean 开发环境中就会做这样的事)，那么上面的程序演示了如何做到。

上例中，getMethod 用于查找一个具有两个整型参数且名为 add 的方法。找到该方法并创建了相应的 Method 对象之后，在正确的对象实例中执行它。执行该方法的时候，需要提供一个参数列表，这在上例中是分别包装了整数 37 和 47 的两个 Integer 对象。执行方法的返回的同样是一个 Integer 对象，它封装了返回值 84。

7.创建新的对象
对于构造器，则不能像执行方法那样进行，因为执行一个构造器就意味着创建了一个新的对象 (准确的说，创建一个对象的过程包括分配内存和构造对象)。所以，与上例最相似的例子如下：
import java.lang.reflect.*;
public class constructor2 {
    public constructor2() {
    }

    public constructor2(int a, int b) {
        System.out.println("a = " + a + " b = " + b);
    }

    public static void main(String args[]) {
        try {
            Class cls = Class.forName("constructor2");
            Class partypes[] = new Class[2];
            partypes[0] = Integer.TYPE;
            partypes[1] = Integer.TYPE;
            Constructor ct = cls.getConstructor(partypes);
            Object arglist[] = new Object[2];
            arglist[0] = new Integer(37);
            arglist[1] = new Integer(47);
            Object retobj = ct.newInstance(arglist);
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}

根据指定的参数类型找到相应的构造函数并执行它，以创建一个新的对象实例。使用这种方法可以在程序运行时动态地创建对象，而不是在编译的时候创建对象，这一点非常有价值。

8.改变字段(域)的值
reflection 的还有一个用处就是改变对象数据字段的值。reflection 可以从正在运行的程序中根据名称找到对象的字段并改变它，下面的例子可以说明这一点：
import java.lang.reflect.*;
public class field2 {
    public double d;
    public static void main(String args[]) {
        try {
            Class cls = Class.forName("field2");
            Field fld = cls.getField("d");
            field2 f2obj = new field2();
            System.out.println("d = " + f2obj.d);
            fld.setDouble(f2obj, 12.34);
            System.out.println("d = " + f2obj.d);
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}

这个例子中，字段 d 的值被变为了 12.34。
9.使用数组
本文介绍的 reflection 的最后一种用法是创建的操作数组。数组在 Java 语言中是一种特殊的类类型，一个数组的引用可以赋给 Object 引用。观察下面的例子看看数组是怎么工作的：
import java.lang.reflect.*;
public class array1 {
    public static void main(String args[]) {
        try {
            Class cls = Class.forName("java.lang.String");
            Object arr = Array.newInstance(cls, 10);
            Array.set(arr, 5, "this is a test");
            String s = (String) Array.get(arr, 5);
            System.out.println(s);
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}

例中创建了 10 个单位长度的 String 数组，为第 5 个位置的字符串赋了值，最后将这个字符串从数组中取得并打印了出来。

下面这段代码提供了一个更复杂的例子：
import java.lang.reflect.*;
public class array2 {
    public static void main(String args[]) {
        int dims[] = new int[]{5, 10, 15};
        Object arr = Array.newInstance(Integer.TYPE, dims);
        Object arrobj = Array.get(arr, 3);
        Class cls = arrobj.getClass().getComponentType();
        System.out.println(cls);
        arrobj = Array.get(arrobj, 5);
        Array.setInt(arrobj, 10, 37);
        int arrcast[][][] = (int[][][]) arr;
        System.out.println(arrcast[3][5][10]);
    }
}
例中创建了一个 5 x 10 x 15 的整型数组，并为处于 [3][5][10] 的元素赋了值为 37。注意，多维数组实际上就是数组的数组，例如，第一个 Array.get 之后，arrobj 是一个 10 x 15 的数组。进而取得其中的一个元素，即长度为 15 的数组，并使用 Array.setInt 为它的第 10 个元素赋值。

注意创建数组时的类型是动态的，在编译时并不知道其类型。