转自：http://blog.csdn.net/program_think/article/details/3996142
考虑写性能优化系列，主要是因为之前看到了太多性能其烂无比的Java代码（有些代码看得我口瞪目呆）。很多Java程序员在写程序时，由于不太了解JVM及语言本身的一些运作机制，从而导致了代码的性能出现严重问题（性能差一个数量级以上，我才称为“严重”）。
虽然网上也有针对Java性能的介绍，但是很多内容都仅仅告诉读者“该这么做”，而没有讲“为什么该这么做”。典型的例子就是关于String和StringBuffer（StringBuilder），光介绍如何用，却没有说为什么这样用。这种现象导致了很多Java程序员只知其然，不知其所以然。所以本系列帖子会尽量介绍一些“所以然”的东东（也就是学习技术三部曲的HOW和WHY），希望对Java程序员有所帮助。
先初步考虑聊如下几个话题：
1、基本类型 vs 引用类型
2、字符串过滤实战
3、关于垃圾回收（GC）
4、finalize函数 5、......
Java性能优化[1]：基本类型 vs 引用类型
在Java性能优化系列中，内存管理是一个要优先考虑的关键因素。而说到内存分配，就必然会涉及到基本类型和引用类型。所以我们今天就先来介绍一下这两种类型在性能方面各自有什么奥妙（关于引用类型的其它奥妙，请看“这里”）。
★名词定义
先明确一下什么是基本类型，什么是引用类型。简单地说，所谓基本类型就是Java语言中如下的8种内置类型：boolean、char、byte、short、int、long、float、double。而引用类型就是那些可以通过new来创建对象的类型（基本上都是派生自Object）。
★两种类型的存储方式
这两种类型的差异，首先体现在存储方式上。
◇引用类型的创建
当你在函数中创建一个引用类型的对象时，比如下面的语句：
StringBuffer str = new StringBuffer();
该StringBuffer对象的内容是存储在堆（Heap）上的，需要申请堆内存。而变量str只不过是针对该StringBuffer对象的一个引用（或者叫地址）。变量str的值（也就是StringBuffer对象的地址）是存储在栈上的。
◇基本类型的创建
当你在函数中创建一个基本类型的变量时，比如如下语句：
int n = 123;
这个变量n的值也是存储在栈（Stack）上的，但是这个语句不需要再从堆中申请内存了。
为了更加形象，便于大伙儿理解，简单画了一个示意图如下：
★堆和栈的性能差异
可能有同学会小声问：堆和栈有啥区别捏？要说堆和栈的差别，那可就大了去了。如果你对这两个概念还是不太明白或者经常混淆，建议先找本操作系统的书拜读一下。
由于本系列是介绍性能，所以来讨论一下堆和栈在性能方面的差别（这个差异是很大滴）。堆相对进程来说是全局的，能够被所有线程访问；而栈是线程局部的，只能本线程访问。打个比方，栈就好比个人小金库，堆就好比国库。你从个人小金库拿钱去花，不需要办什么手续，拿了就花，但是钱数有限；而国库里面的钱虽然很多，但是每次申请花钱要打报告、盖图章、办N多手续，耗时又费力。
同样道理，由于堆是所有线程共有的，从堆里面申请内存要进行相关的加锁操作，因此申请堆内存的复杂度和时间开销比栈要大很多；从栈里面申请内存，虽然又简单又快，但是栈的大小有限，分配不了太多内存。
★为什么这样设计？
可能有同学又问了，干嘛把两种类型分开存储，干嘛不放到一起捏？这个问题问得好！下面我们就来揣测一下，当初Java为啥设计成这样。
当年Java它爹（James Gosling）设计语言的时候，对于这个问题有点进退两难。如果把各种东东都放置到栈中，显然不现实，一来栈是线程私有的（不便于共享），二来栈的大小是有限的，三来栈的结构也间接限制了它的用途。那为啥不把各种东东都放置到堆里面捏？都放堆里面，倒是能绕过上述问题，但是刚才也提到了，申请堆内存要办很多手续，太繁琐。如果仅仅在函数中写一个简单的“int n = 0;”，也要到堆里面去分配内存，那性能就大大滴差了（要知道Java是1995年生出来的，那年头我家的PC配4兆内存就属豪华配置了）。
左思右想之后，Java它爹只好做了一个折中：把类型分为基本类型和引用类型，两者使用不同的创建方式。这种差异从Java语法上也可以看出来：引用类型可以用new创建对象（对于某些单键，表面上没用new，但是在getInstance()内部也还是用的new）；而基本类型则不需要用new来创建。
★这样设计的弊端
顺便跑题一下，斗胆评价Java它爹这种设计的弊端（希望Java Fans不要跟我急）。我个人认为：这个折中的决策，带来了许多深远的影响，随手举出几个例子：
1、由于基本类型不是派生自Object，因此不能算是纯种的对象。这导致了Java的“纯面向对象”招牌打了折扣（当年Sun老是吹嘘Java是纯OO的语言）。
2、由于基本类型不是派生自Object，出于某些场合（比如容器类）的考虑，不得不为每个基本类型加上对应的包装类（比如Integer、Byte等），使得语言变得有点冗余。
★结论
从上述的介绍，我们应该明白，使用new创建对象的开销是不小的。在程序中能避免就应该尽量避免。另外，使用new创建对象，不光是创建时开销大，将来垃圾回收时，销毁对象也是有开销的（关于GC的开销，咱们会在后面的帖子细谈）。下一个帖子，我们找一个例子来实战一下。
上一个帖子已经介绍了基本类型和引用类型的性能差异（主要是由于内存分配方式不同导致）。为了给列位看官加深印象，今天拿一个具体的例子来实地操作一把，看看优化的效果如何。
★关于需求
首先描述一下需求，具体如下：给定一个String对象，过滤掉除数字（字符'0'-'9'）以外的其它字符。要求时间开销尽可能小。过滤函数的原型如下：String filter(String str);
针对上述需求，我写了5个不同的过滤函数。为了叙述方便，分别称为filter1到filter5。其中filter1性能最差、filter5性能最好。在你接着看后续的内容之前，你先暗自思考一下，如果由你来实现该函数，大概会写成什么样？最好把你想好的函数写下来，便于后面的对比。
★代码实现
◇测试代码
为了方便测试性能，先准备好一个测试代码，具体如下：
- class Test
- {
- public static void main(String[] args)
- {
- if(args.length != 1)
- {
- return;
- }
- String str = "";
- long nBegin = System.currentTimeMillis();
- for(int i=0; i<1024*1024; i++)
- {
- str = filterN(args[0]); //此处调用某个具体的过滤函数
- }
- long nEnd = System.currentTimeMillis();
- System.out.println(nEnd-nBegin);
- System.out.println(str);
- }
- };
在没有想好你的实现方式之前，先别偷看后续内容哦！另外，先注明一下，我使用的Java环境是JDK1.5.0-09，使用的测试字符串为“D186783E36B721651E8AF96AB1C4000B”。由于JDK版本和机器性能不尽相同，你在自己机器上测试的结果可能和我下面给出的数值不太一样。
◇版本1
先来揭晓性能最差的filter1，代码如下：
- private static String filter1(String strOld)
- {
- String strNew = new String();
- for(int i=0; i<strOld.length(); i++)
- {
- if('0'<=strOld.charAt(i) && strOld.charAt(i)<='9')
- {
- strNew += strOld.charAt(i);
- }
- }
- return strNew;
- }
如果你的代码不幸和filter1雷同，那你的Java功底可就是相当糟糕了，连字符串拼接需要用StringBuffer来优化都没搞明白。
为了和后续对比，先记下filter1的处理时间，大约在8.81-8.90秒之间。
◇版本2
再来看看filter2，代码如下：
- private static String filter2(String strOld)
- {
- StringBuffer strNew = new StringBuffer();
- for(int i=0; i<strOld.length(); i++)
- {
- if('0'<=strOld.charAt(i) && strOld.charAt(i)<='9')
- {
- strNew.append(strOld.charAt(i));
- }
- }
- return strNew.toString();
- }
其实刚才在评价filter1的时候，已经泄露了filter2的天机。filter2通过使用StringBuffer来优化连接字符串的性能。为什么StringBuffer连接字符串的性能比String好，这个已经是老生常谈，我就不细说了。尚不清楚的同学自己上Google一查便知。我估计应该有挺多同学会写出类似filter2的代码。
另外，JDK1.5新增加了StringBuilder，性能会比StringBuffer更好，不过考虑到有可能要拿到其它版本的JDK上作对比测试，而且StringBuilder和StringBuffer之间的差异不是本文讨论的重点，所以后面的例子都使用StringBuffer来实现。
filter2的处理时间大约为2.14-2.18秒，提升了大约4倍。
◇版本3
接着看看filter3，代码如下：
- private static String filter3(String strOld)
- {
- StringBuffer strNew = new StringBuffer();
- int nLen = strOld.length();
- for(int i=0; i<nLen; i++)
- {
- char ch = strOld.charAt(i);
- if('0'<=ch && ch<='9')
- {
- strNew.append(ch);
- }
- }
- return strNew.toString();
- }
乍一看filter3和filter2的代码差不多嘛！你再仔细瞧一瞧，原来先把strOld.charAt(i)赋值给char变量，节省了重复调用charAt()方法的开销；另外把strOld.length()先保存为nLen，也节省了重复调用length()的开销。能想到这一步的同学，估计是比较细心的。
经过此一优化，处理时间节省为1.48-1.52，提升了约30%。由于charAt()和length()的内部实现都挺简单的，所以提升的性能不太明显。
另外补充一下，经网友反馈，在JDK 1.6上，filter3和filter2的性能基本相同。可能是由于JDK 1.6已经进行了相关的优化。
◇版本4
然后看看filter4，代码如下：
- private static String filter4(String strOld)
- {
- int nLen = strOld.length();
- StringBuffer strNew = new StringBuffer(nLen);
- for(int i=0; i<nLen; i++)
- {
- char ch = strOld.charAt(i);
- if('0'<=ch && ch<='9')
- {
- strNew.append(ch);
- }
- }
- return strNew.toString();
- }
filter4和filter3差别也很小，唯一差别就在于调用了StringBuffer带参数的构造函数。通过StringBuffer的构造函数设置初始的容量大小，可以有效避免append()追加字符时重新分配内存，从而提高性能。
filter4的处理时间大约在1.33-1.39秒。约提高10%，可惜提升的幅度有点小 :-(
◇版本5
最后来看看终极版本，性能最好的filter5。
- private static String filter5(String strOld)
- {
- int nLen = strOld.length();
- char[] chArray = new char[nLen];
- int nPos = 0;
- for(int i=0; i<nLen; i++)
- {
- char ch = strOld.charAt(i);
- if('0'<=ch && ch<='9')
- {
- chArray[nPos] = ch;
- nPos++;
- }
- }
- return new String(chArray, 0, nPos);
- }
猛一看，你可能会想：filter5和前几个版本的差别也忒大了吧！filter5既没有用String也没有用StringBuffer，而是拿字符数组进行中间处理。
filter5的处理时间，只用了0.72-0.78秒，相对于filter4提升了将近50%。为啥捏？是不是因为直接操作字符数组，节省了append(char)的调用？通过查看append(char)的源代码，内部的实现很简单，应该不至于提升这么多。
那是什么原因捏？
首先，虽然filter5有一个字符数组的创建开销，但是相对于filter4来说，StringBuffer的构造函数内部也会有字符数组的创建开销。两相抵消。所以filter5比filter4还多节省了StringBuffer对象本身的创建开销。（在我的JDK1.5环境中，这个因素比较明显）
其次，由于StringBuffer是线程安全的（它的方法都是synchronized），因此调用它的方法有一定的同步开销，而字符数组则没有，这又是一个性能提升的地方。（经网友反馈，此因素在JDK 1.6中比较明显）
基于上述两个因素，所以filter5比filter4又有较大幅度的提升。
★ 对于5个版本的总结
上述5个版本，filter1和filter5的性能相差约12倍（已经超过一个数量级）。除了filter3相对于filter2是通过消除函数重复调用来提升性能，其它的几个版本都是通过节省内存分配，降低了时间开销。可见内存分配对于性能的影响有多大啊！如果你是看了 上一个帖子才写出filter4或者filter5，那说明你已经领会了个中奥妙，我那个帖子也就没白写了。
★ 一点补充说明，关于时间和空间的平衡
另外，需要补充说明一下。版本4和版本5使用了空间换时间的手法来提升性能。假如被过滤的字符串 很大，并且数字字符的比例 很低，这种方式就不太合算了。
举个例子：被处理的字符串中，绝大部分都只含有不到10%的数字字符，只有少数字符串包含较多的数字字符。这时候该怎么办捏？对于filter4来说，可以把new StringBuffer(nLen);修改为newStringBuffer(nLen/10);来节约空间开销。但是filter5就没法这么玩了。
所以，具体该用版本4还是版本5，要看具体情况了。只有在你 非常看重时间开销，且数字字符比例很高（至少大于50%）的情况下，用filter5才合算。否则的话，建议用filter4。
下一个帖子，打算介绍一下“ 关于垃圾回收（GC）”的话题。
版权声明
本博客所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者编程随想和本文原始地址：
http://program-think.blogspot.com/2009/03/java-performance-tuning-2-string.html
Java新手进阶：细说引用类型
在前几天的帖子“ Java性能优化[1]：基本类型 vs 引用类型”里，大概介绍了引用类型和基本类型在存储上的区别。昨天有网友在评论中批评说“引用类型变量和它所引用的对象”没区分清楚，容易混淆。所以今天专门来说一下引用类型的相关细节。另外，也把 原先的帖子中，关于“两种类型的存储方式”这节修改了一下，加点插图，有助于大伙儿的理解。
其实，引用类型的变量非常类似于C/C++的指针。为了形象起见，也为了打字方便，本文后面的内容，都把“引用类型的变量”称为 指针。所以，如果你原先有C/C++背景，今天讲的内容对你来说应该很好理解；否则的话，可能要多琢磨琢磨了。
★ 创建问题
假设我们在 函数中写了如下这个简单的语句：
StringBuffer str = new StringBuffer("Hello world");
别看这个语句简单，其实包含了如下三个步骤：
首先， new StringBuffer("Hello world")在 堆里申请了一坨内存，把创建好的StringBuffer对象放进去。
其次， StringBuffer str声明了一个指针。这个指针本身是存储在 栈上的（因为语句写在 函数中），可以用来指向某个StringBuffer类型的对象。或者换一种说法，这个指针可以用来保存某个StringBuffer对象的地址。
最后，当中这个 等于号（赋值符号）把两者关联起来，也就是把刚申请的那一坨内存的地址保存成str的值。
把 上次帖子的图片再拿出来秀一下：
★引用对象之间的赋值、判相等
通过上述的图解，大伙儿应该明白指针变量和该指针变量指向的对象是一个什么关系了吧。
还是接着刚才的例子，再来看赋值的问题。对于如下语句：
StringBuffer str2 = str;
这个赋值语句是啥意思捏？实际上就是把str的地址复制给str2，记住，是地址的复制，StringBuffer对象本身并没有复制。所以两个指针指向的是同一个东东。
再搞一张示意图，如下（今天画这些图把我累坏了）：
明白了赋值，判断相等的问题（就是==操作符）也就简单了。当我们写如下语句“if(str2 == str)”时，只是判断两个指针的值（也就是对象的地址）是否相等，并不是判断被指向的对象是否内容相同。
实际上两个指针的值相同，则肯定是指向同一个对象（所以对象内容必定相同）。但是两个内容相同的对象，它们的地址可能不一样（比如克隆出来的多个对象之间，地址就不同）。
★final常量的问题
针对引用类型变量的final修饰符也是很多人搞混淆的地方。实际上final只是修饰指针的值（也就是限定指针保存的地址不能变）。至于该指针指向的对象，内容是否能变，那就管不着了。所以，对于如下语句：
final StringBuffer strConst = new StringBuffer();
你可以修改它指向的对象的内容，比如：
strConst.append(" ");
但是不能修改它的值，比如：
strConst = null;
★传参的问题
引用类型（在函数调用中）的传参问题，是一个相当扯的问题。有些书上说是传值，有些书上说是传引用。搞得Java程序员都快成神经分裂了。所以，我们最后来谈一下“引用类型参数传递”的问题。
还是拿刚才的例子，假设现在要把刚才创建的那一坨字符串打印出来，我们会使用如下语句：
System.out.println(str);
这个语句又是什么意思捏？这时候就两说了。
第一种理解：
可以认为传进函数的是str这个指针，指针说白了就是一个地址的值，说得再白一点，就是个整数。按照这种理解，就是传值的方式。也就是说，参数传递的是指针本身，所以是传值的。
第二种理解：
可以认为传进去的是StringBuffer对象，按照这种理解，就是传引用方式了。因为我们确实是把对象的地址（也就是引用）给传了进去。
费了这么多口水，其实不论是传引用还是传值，都可以讲得通，关键取决于你是如何看待参数所传递的东西。这就好比量子力学中“光的波粒二象性”，如果你以粒子的方式去测量它，它看起来像粒子；如果你以波动的方式去观测它，它看起来像波动。假如你不太懂量子力学，前面这话当我没说:-)
版权声明
本博客所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者编程随想和本文原始地址：
http://program-think.blogspot.com/2009/03/java-reference-types-detail.html
1357
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
