本篇是《深入理解Java虚拟机-Java 高级特性与最佳实践》学习笔记，周志明著，Understanding the JVM-Advanced Features and Best Practices，机械工业出版社，2011.6出版。

重温Java JVM知识，重点学习了与日常开发工作相关性最大的“自动化内存管理”模块，对Java容器优化、内存问题解决很有帮助；习惯了从互联网看电子书，难以集中和记忆，现在找几本纸质书重温，可以很清静、很安静的理解和消化，受益匪浅。

自动内存管理机制

Java和C++之间有一睹由动态内存分配和垃圾收集机制组成的墙，里面的人想出来，外面的人想进去。

在Java里面调用System.gc，会立刻引起一次FullGC和YougGC。

1、Java内存区域与内存溢出异常

JDK5.0以后每个线程栈大小为1M，之前每个线程栈大小为256K。

应当根据应用的线程所需内存大小进行调整。在相同物理内存下，减小这个值能生成更多的线程。但是操作系统对一个进程内的线程数还是有限制的，不能无限生成，经验值在3000~5000左右。

需要注意的是：当这个值被设置的较大（例如>2MB）时将会在很大程度上降低系统的性能。

如果我们需要知道，JVM虚拟机的默认参数配置，可以使用命令查看：

java -XX:+PrintFlagsInitial | grep Ratio

我们可以看到，新生代和老年代的默认比值是2；Survior和Eden的默认比值是8.

JVM实用参数（三）打印所有XX参数及值

补充一个案例，如下：

如果写了一个普通的死循环，没有发现，则会占用cpu时间，但是可能不会导致内存溢出的情况，因为可能对于堆和栈空间都没有太大影响；

但是如果写了个递归死循环，循环递归，则马上会报StackOverFlow，因为随着递归函数的调用，大量的本地变量被声明，很快，栈空间就满了；

另，对于不同的JDK，可能会变化，比如String的常量String.intern()，在JDK6中存放在“方法区”的“运行时常量池”中，但是在JDK7中，就存放在堆中了，所以，很多细节也是在一直变化中的。。。

参考网址：

http://blog.csdn.net/kthq/article/details/8618052

http://www.open-open.com/lib/view/open1324736648468.html

2、垃圾收集器与内存分配策略

对象已死的确定方法：

垃圾收集算法：

垃圾收集器（垃圾收集算法是方法论，垃圾收集器是实现）：

JDK6默认的垃圾收集器：

JVM默认的客户端还是服务器模式，取决于下面的情况：

内存分配策略：

对象优先在Eden分配、大对象直接进入老年代、长期存活的对象将进入老年代、动态对象年龄判定、空间分配担保

验证了前3条内存分配策略，在Win8.164bit及RHEL6.164bit下，和书中描述规则不一致，原因是我的i5-3210CPU被识别为AMD64，所以是默认以Server方式启动JVM，采用ParallelGC；我在启动JVM时，加上参数-XX:+UseSerialGC，强制使用SerialGC，则案例验证通过；PretenureSizeThreshold，即设定直接进入老年代的大对象尺寸的参数，只对Serial和ParNew生效；

也由此可见，内存分配策略具有非常复杂的规则，不仅仅是这几条规则所能描述的。

总结：经过半个世纪的发展，内存的动态分配和回收技术已经相当成熟；但是当需要排查各种内存溢出、内存泄露问题时，当垃圾收集成为系统达到更高并发量的瓶颈时，我们就需要对这些“自动化”的技术实施必要的监控和调节。

查看JVM进程使用的垃圾回收器：

jinfo -flag UseSerialGC 60282
jinfo -flag UseParNewGC 60282
jinfo -flag UseParallelGC 60282
jinfo -flag UseParallelOldGC 60282
jinfo -flag UseConcMarkSweepGC 60282

在RHEL6.3虚拟机（1G内存、单核）下，全部输出-，没有+，不知道原因，截图如下：

在CentOS虚拟机(32G内存、8核）下，正常输出UseParallelGC，截图如下：

jstat -gccause -h10 pid 2000

http://phl.iteye.com/blog/2004211

参考文章：

http://jeromecen1021.blog.163.com/blog/static/18851527120117274624888/

http://blog.csdn.net/gugemichael/article/details/9345803  讲GC的，S0、S1为什么总有一个是空的

http://www.fasterj.com/articles/oraclecollectors1.shtml

http://blog.csdn.net/dc_726/article/details/7934101

http://jbutton.iteye.com/blog/1569746

3、内存性能分析与故障处理工具

jstack  -l -F 15348 >> 169.txt 

sudo -u root /usr/java/jdk1.6.0_26/bin/jstack -F 15348

在JDK6U23之前，执行jstack,jmap -F会有Bug，看这个文章：http://developer.51cto.com/art/201203/321359.htm

jstat -gcutil -h10 pid 1000

GC的时间单位是：second

MAT(Memory Analyzer Tool)

除了以上之外，另外推荐一个内存分析工具，下载地址：http://www.eclipse.org/mat/downloads.php，它分析的是JVM内存的dump文件，此文件可以通过jmap -dump:format=b,file=xxx.bin pid将内存dump出来，也可以通过设置-XX:+HeapDumpOnOutOfMemoryError参数，在JVM出现OOM时自动输出到文件；或者在VisualVM中直接对监控的JVM进程单击右键，选择“Heap Dump”，将JVM的内存dump出来。

BTrace

下载地址：https://kenai.com/projects/btrace/downloads/directory/releases

写一段脚本，随时切入正在运行的程序，跟踪代码的调用。写一段Btrace脚本还是很麻烦的，不详述了。

其他的工具还有：HSDB，Java自带的，执行方式如下：

java -classpath .:$JAVA_HOME/lib/sa-jdi.jar sun.jvm.hotspot.CLHSDB

jvisualvm

可以远程监控Java进程，比如Tomcat，增加启动参数：

JAVA_OPTS=”-Dcom.sun.management.jmxremote.port=9998 -Dcom.sun.management.jmxremote.ssl=false -Dcom.sun.management.jmxremote.authenticate=false -Djava.rmi.server.hostname=10.10.10.212″

或者java进程，启动时增加参数，比如：

java -Xms2048m -Xmx46080m -classpath $CLASSPATH -Dcom.sun.management.jmxremote.port=9998 -Dcom.sun.management.jmxremote.ssl=false -Dcom.sun.management.jmxremote.authenticate=false -Djava.rmi.server.hostname=10.10.10.212 com.yougou.recommend.service.ViewViewServiceReverse >> “$stats_log”

则可以在本地通过jvisualvm监控进程情况，在命令行输入jvisualvm，远程，连接ip地址，之后右键这个远程连接，新建JMX连接，输入端口，则可以监控这个远程java进程了。

4、调优案例分析与实战

高性能硬件上的程序部署策略：

集群间同步导致的内存溢出：

堆外内存导致的溢出错误：

外部命令导致系统缓慢：

服务器JVM进程崩溃：

Java虚拟机的内存管理与垃圾回收是虚拟机结构体系中最重要的组成部分，对我们程序的性能和稳定性有着非常大的影响。

虚拟机执行系统：类加载、编译和执行

这一部分深入讲解了虚拟机的执行过程，对实际工作中的帮助相对较小，这里只记录下篇章，及一些领悟，不做深入学习。

篇章：《类文件结构》、《虚拟机类加载机制》、《虚拟机字节码执行引擎》、《类加载及执行子系统的案例与实战》、《编译器优化》、《运行期优化》

这些篇章介绍了Class文件格式、类加载及迅疾执行引擎，这些内容是虚拟机中必不可少的部分，了解了虚拟机如何执行程序，才能更好地理解怎样才能写出优秀的代码。

代码编译的结果从本地机器码变为字节码，是存储格式发展的一小步，却是编程语言发展的一大步。

Java语言规范和Java虚拟机规范是分别定义的，这说明任何语言，编译成的字节码只要符合Java虚拟机规范，都可以在Java虚拟机执行，当前这样的语言有：Clojure,Groovy,JRuby,Jython。

Java程序从源码编译成字节码和从字节码编译成本地机器码的过程，Javac字节码编译器与虚拟机内的JIT编译器的执行过程合并起来，其实就等于一个传统的编译器所执行的编译过程。

对Java编译器的深入了解，有助于在工作中分辨哪些代码是编译器可以帮我们处理的，哪些代码需要自己调节以便更适合编译器的优化。

高效并发

并发处理的广泛应用是使得Amdahl定律代替摩尔定律成为计算机性能发展源动力的根本原因，也是人类压榨计算机运算能力最有力的武器。

volatile修饰符，当一个变量被定义为volatile后，则此变量对多有线程可见，即新值修改了值后，其他线程立即得知；但是这种类型不是原子性的， 依然做不到线程安全，书中有实例。

immutable的 对象一定是线程安全的，比如String对象。

绝对线程安全的对象几乎没有，书中演示了Vector对象多线程移除，get时获取不到的情况，依然需要对vector对象加锁才保证了正确的结果。Java API中，绝大多数的线程安全类，都是相对线程安全的。

suspend，resume，setIn，setOut，runFinalizersOnExit等有死锁风险，被废弃。

线程安全最常用的实现，就是互斥同步，是阻塞的，利用synchronized。

本书的后面部分，关于虚拟机执行系统的，关于编译优化的，关于高效并发的，和实际编码、架构等技术性工作的相关性相对较低，在此不进行进一步的深入学习。

内存溢出代码示例

HeapSize OOM — Java heap space

class HeapOOM {
        public static void main(String[] args) {
                java.util.List<String> list = new java.util.ArrayList<String>();
                while(true) {
                        list.add("内存溢出啊，内粗溢出啊！");
                }
        }
}

执行java -Xmx2m HeapOOM，堆内存瞬间溢出，报错：java.lang.OutOfMemoryError:Java heap space

HeapSize OOM — GC over head limit exceeded

import java.util.*;
class GCOverHead {
        public final static byte[] DEFAULT_BYTES = new byte[12*1024*1024];
        public static void main(String[] args) {
                List<byte[]> temp = new ArrayList<byte[]>();
                while(true) {
                        temp.add(new byte[1024*1024]);
                        if(temp.size()>3) {
                                temp.clear();
                        }
                }
        }
}

执行java -XX:+PrintGCDetails -XX:+UseGCOverheadLimit -Xmn5m -Xmx20m GCOverHead ，据说会报java.lang.OutOfMemoryError:GC over head limit exceeded，意思是不断在做Full GC，每次GC完后释放一点点内存，然后一下子就又满了，不断重复，当次数达到一定量，并且平均FULL GC时间达到一定比例时，就会报错；

但是，我的程序一直就无限循环运行，不报错误。。。

PermGen OOM

import net.sf.cglib.proxy.Enhancer;
class ClassPermGenOOM {
        public static void main(String[] args) {
                while(true) {
                        createProxy(ClassPermGenOOM.class);
                }
        }
        public static Object createProxy(Class<?> targetClass) {
                Enhancer enhancer = new Enhancer();
                enhancer.setSuperclass(targetClass);
                enhancer.setUseCache(false);
                enhancer.setCallback(new MethodInterceptor() {
                        public Object intercept(Object object,
                                Method method,Object[] args,
                                MethodProxy methodProxy) throws Throwable {
                                return methodProxy.invokeSuper(object,args);
                        }       
                });
                return enhancer.create();
        }
}

执行java -XX:+TraceClassUnloading -XX:PermSize=10m -XX:MaxPermSize=10 ClassPermGenOOM，会报出java.lang.OutOfMemoryError:PermGen space错我。

DirectBuffer OOM

import java.nio.ByteBuffer;
class ByteBufferOOM {
        public static void main(String[] args) {
                ByteBuffer.allocateDirect(257*1024*1024);
        }
}
~ 

执行java -XX:MaxDirectMemorySize=256m ByteBufferOOM，则会报出错误java.lang.OutOfMemoryError:Direct bufer memory。

StackOverflowError

栈溢出，无限递归即可。

死递归和死循环不一样，死循环时，栈空间不会递增；而死递归由于需要记录退回的路径，就必须记住递归过程中的方法调用过程，以及每个方法运行过程中的本地变量，这个我们称之为上下文信息，随着内容的增加，就会占用更多的内存空间，JVM是为了控制它的无限制增长，才做了安全检测的处理。