关于性能优化

我发现一个现象，很多两三年以下的人写代码动不动就扯性能，其实他们大部分人根本不知道到底哪是性能瓶颈，函数调用的效率，CPU执行指令需要的时间...工作效率低不说，还考虑很多没用的东西。个人感觉，性能这个东西应该考虑：
1.考虑程序的应用范围。如果你是给核反应堆写实时程序，那每一步你可能都得考虑，其他就大部分通用程序而言，你不用每一步都考虑。
2.性能要考虑关键瓶颈。不是每一步都是关键，关键瓶颈不是写之前提前考虑出来的，而是测出来的。很多你以为瓶颈的地方往往不是瓶颈。
3.低效的算法+大量的处理数据两者结合往往是导致效率低下的根本原因，而函数调用，拆分函数等不是。JAVA初学者喜欢怀疑函数调用，C++派则彻底怀疑继承结构和堆上的数据，很有意思的现象。即使低效的算法处理小量数据也没必要优化，e.g.冒泡排序和快速排序在排少量数据的时候的性能差异不需要考虑。

大家说说自己的看法。

P.S.编程里面真的有很多不符合直觉的结论。比如边开发边考虑性能优化是否必要，比如添加人手是否能提高项目进度，真的是很有意思。

评论

55 楼 蔡华江 2010-11-17  

ironsabre 写道

蔡华江 写道

ironsabre 写道

flysnowxf 写道

ironsabre 写道

flysnowxf 写道

汗，这是很基础的概念了。
百度百科：http://baike.baidu.com/view/714962.htm

引用

当以前分配的一片内存不再需要使用或无法访问时，但是却并没有释放它，那么对于该进程来说，会因此导致总可用内存的减少，这时就出现了内存泄漏。

再说一次，向集合里一直加东西不删除，这个不叫内存泄漏。

那是你的理解了。我的理解是，分配了内存，但这些内存不再被使用，比如过期了、没用了，但又没有去删除，造成内存占用越来越多。HashMap的使用就容易出现这个问题。

哎。你这个没过期，也有用。你可以通过HashMap取出来值的，这怎么能叫泄漏呢？
我现在总是你，如果你向cache里放了100个对象，永远keep住，如果我应用程序经常来访问它，叫不叫泄漏？
如果我应用程序再也不来访问它，叫不叫泄漏？
按你的理解，第一种不叫，第二种叫。可这两种没有区别。我不可能用由第三方来判断我自己是不是泄漏，明白吗？

下面这个Stack，在被别人用的时候，可能会引起泄漏。你先找找看哪行会出总是。然后再理解一下跟你这个有什么区别。
import java.util.Arrays;
import java.util.EmptyStackException;

public class Stack {
private Object[] elements;
private int size = 0;
private static final int DEFAULT_INITIAL_CAPACITY = 16;

public Stack() {
elements = new Object[DEFAULT_INITIAL_CAPACITY];
}

public void push(Object e) {
ensureCapacity();
elements[size++] = e;
}

public Object pop() {
if (size == 0)
throw new EmptyStackException();
return elements[--size];
}

/**
* Ensure space for at least one more element, roughly doubling the capacity
* each time the array needs to grow.
*/
private void ensureCapacity() {
if (elements.length == size)
elements = Arrays.copyOf(elements, 2 * size + 1);
}
}

你这个封装Object[]的Stack跟封装HashMap的Cache有什么区别？
内存泄漏是指存在无法释放的无用引用，从这点来说，HashMap里面的内容也是内存泄漏。

HashMap里的内容你仍然可以自由的存取的，这不叫泄漏，你觉得内存不够用了，你可以去删除掉一些。这完全可以自己控制的，这叫什么泄漏？？那按你这个说法，只要向容器里放对象就是泄漏了？？

我们现在再看这个Stack类，我把这个Stack类打成一个jar包，然后我提供给你用，你用上面这个Stack作为你的容器，你push一万次，再pop一万次，你的Stack的size已经是0了，但是这一万个对象仍然无法放掉(前提当然是Stack本身要被keep住)。你会有一些内存你已经永远无法使用了，而且你已经没有任何能力去放掉它了(不包括回收到Stack本身)。
看得懂区别了吗？？

是你没看懂我的意思。我指的是“封装了HashMap"的Cache。
你如果能拿到Stack中Object[]的引用，你一样可以对数组进行操作。
如果你拿不到HashMap的引用，你一样无法对数组进行操作。
所以问题并不是hashMap本身。
其次，就算你能拿到HashMap本身，我也认为这是内存泄漏。请注意,"内存泄漏是指存在无法释放的无用引用"。
Java最大特色在于内存的自动释放。
Object a = new Object();
。。。
a = null;
显然，a是释放了的，至少程序员的本意是要释放a的，但是由于集合中保存了另一个a的引用（这个总是很隐蔽的），导致a的内存并没有释放，这不是溢出，这是泄漏。

54 楼 ironsabre 2010-11-17  

蔡华江 写道

ironsabre 写道

flysnowxf 写道

ironsabre 写道

flysnowxf 写道

汗，这是很基础的概念了。
百度百科：http://baike.baidu.com/view/714962.htm

引用

当以前分配的一片内存不再需要使用或无法访问时，但是却并没有释放它，那么对于该进程来说，会因此导致总可用内存的减少，这时就出现了内存泄漏。

再说一次，向集合里一直加东西不删除，这个不叫内存泄漏。

那是你的理解了。我的理解是，分配了内存，但这些内存不再被使用，比如过期了、没用了，但又没有去删除，造成内存占用越来越多。HashMap的使用就容易出现这个问题。

哎。你这个没过期，也有用。你可以通过HashMap取出来值的，这怎么能叫泄漏呢？
我现在总是你，如果你向cache里放了100个对象，永远keep住，如果我应用程序经常来访问它，叫不叫泄漏？
如果我应用程序再也不来访问它，叫不叫泄漏？
按你的理解，第一种不叫，第二种叫。可这两种没有区别。我不可能用由第三方来判断我自己是不是泄漏，明白吗？

下面这个Stack，在被别人用的时候，可能会引起泄漏。你先找找看哪行会出总是。然后再理解一下跟你这个有什么区别。
import java.util.Arrays;
import java.util.EmptyStackException;

public class Stack {
private Object[] elements;
private int size = 0;
private static final int DEFAULT_INITIAL_CAPACITY = 16;

public Stack() {
elements = new Object[DEFAULT_INITIAL_CAPACITY];
}

public void push(Object e) {
ensureCapacity();
elements[size++] = e;
}

public Object pop() {
if (size == 0)
throw new EmptyStackException();
return elements[--size];
}

/**
* Ensure space for at least one more element, roughly doubling the capacity
* each time the array needs to grow.
*/
private void ensureCapacity() {
if (elements.length == size)
elements = Arrays.copyOf(elements, 2 * size + 1);
}
}

你这个封装Object[]的Stack跟封装HashMap的Cache有什么区别？
内存泄漏是指存在无法释放的无用引用，从这点来说，HashMap里面的内容也是内存泄漏。

HashMap里的内容你仍然可以自由的存取的，这不叫泄漏，你觉得内存不够用了，你可以去删除掉一些。这完全可以自己控制的，这叫什么泄漏？？那按你这个说法，只要向容器里放对象就是泄漏了？？

我们现在再看这个Stack类，我把这个Stack类打成一个jar包，然后我提供给你用，你用上面这个Stack作为你的容器，你push一万次，再pop一万次，你的Stack的size已经是0了，但是这一万个对象仍然无法放掉(前提当然是Stack本身要被keep住)。你会有一些内存你已经永远无法使用了，而且你已经没有任何能力去放掉它了(不包括回收到Stack本身)。
看得懂区别了吗？？

53 楼 kingkan 2010-11-17  

抛出异常的爱 写道

kingkan 写道

在下的一点愚见：性能优化在于平时开发习惯的积累，新手因为知识深度面的缺乏而想不到程序高效的写法很正常，老手开发一般写出来的代码都是比较高效的，所以在开发过程中对于过于考虑性能优化是没多大必要，关键是开发前考虑的吞吐量，系统框架在I/O上瓶颈，还有热路径等，进入开发后就是代码工作啦，测试，Beta，Release，上线，维护。

不要犯错就差不多了
设计的好就不太需要考虑优化的事.
必竟j2ee又不是c
我平时很少进行coding时考虑性能问题.

呵呵，老手一般在潜意识里面已经coding优化了，写出来的代码通常都没问题，剩下就交给QA吧

52 楼 指尖帝 2010-11-17  

bitray 写道

赞成2楼和三楼的观点。虽然可能平时大家注意的并不是真正的性能瓶颈。但是如果不重视自己代码的书写规范和简洁，那么写出来的代码就是隐藏的瓶颈，是你最后很难优化出来的东西。有习惯的程序员用stringbuffer和stringbuilder，但是如果是不重视，就会有人用+连接，在多处，一定数据量的情况下，都可能产生隐含问题等

jdk6的字符串拼接内部是用Stringbuilder实现的，现在在sb上纠缠是不明智的。大多情况下+的性能比StringBuilder高

51 楼 蔡华江 2010-11-17  

ironsabre 写道

flysnowxf 写道

ironsabre 写道

flysnowxf 写道

汗，这是很基础的概念了。
百度百科：http://baike.baidu.com/view/714962.htm

引用

当以前分配的一片内存不再需要使用或无法访问时，但是却并没有释放它，那么对于该进程来说，会因此导致总可用内存的减少，这时就出现了内存泄漏。

再说一次，向集合里一直加东西不删除，这个不叫内存泄漏。

那是你的理解了。我的理解是，分配了内存，但这些内存不再被使用，比如过期了、没用了，但又没有去删除，造成内存占用越来越多。HashMap的使用就容易出现这个问题。

哎。你这个没过期，也有用。你可以通过HashMap取出来值的，这怎么能叫泄漏呢？
我现在总是你，如果你向cache里放了100个对象，永远keep住，如果我应用程序经常来访问它，叫不叫泄漏？
如果我应用程序再也不来访问它，叫不叫泄漏？
按你的理解，第一种不叫，第二种叫。可这两种没有区别。我不可能用由第三方来判断我自己是不是泄漏，明白吗？

下面这个Stack，在被别人用的时候，可能会引起泄漏。你先找找看哪行会出总是。然后再理解一下跟你这个有什么区别。
import java.util.Arrays;
import java.util.EmptyStackException;

public class Stack {
private Object[] elements;
private int size = 0;
private static final int DEFAULT_INITIAL_CAPACITY = 16;

public Stack() {
elements = new Object[DEFAULT_INITIAL_CAPACITY];
}

public void push(Object e) {
ensureCapacity();
elements[size++] = e;
}

public Object pop() {
if (size == 0)
throw new EmptyStackException();
return elements[--size];
}

/**
* Ensure space for at least one more element, roughly doubling the capacity
* each time the array needs to grow.
*/
private void ensureCapacity() {
if (elements.length == size)
elements = Arrays.copyOf(elements, 2 * size + 1);
}
}

你这个封装Object[]的Stack跟封装HashMap的Cache有什么区别？
内存泄漏是指存在无法释放的无用引用，从这点来说，HashMap里面的内容也是内存泄漏。

50 楼 dsjt 2010-11-17  

ouchxp 写道

JDK自己已经有优化了. 不合理的优化反而会降低效率
比如字符串常量拼接

String str ="aaa" + "bbb" +"ccc" + "ddd";

StringBuilder sb = new StringBuilder();
sb.append("aaa");
sb.append("bbb");
sb.append("ccc");
sb.append("ddd");
String str = sb.toString();

哪种效率高? 答案是第一种. 对于新手来说想优化很容易适得其反.
反编译看一下就知道为什么了.

我们项目经理不让用第一种

49 楼 抛出异常的爱 2010-11-17  

ouchxp 写道

kyh23_y 写道

既然那些对象我一直在用,那为什么会被叫做是泄露?难道我用那100个对象也有错?
应该是当我没用那所有对象,或者是某些对象的时候,又没有在Map里面remove掉那些对象,导致了map一直持有引用,根据gc的原理,这样的对象是不会被回收的,这样才造成了泄露吧.这是我的理解

存在对象不代表正在使用. 已经不需要再使用的对象,但没有清除掉引用.仍然是内存泄露.
在Java中内存泄露的概念与C++不同.因为Java有自动的垃圾回收.
所以很少会有C++中的已无引用但是内存未释放的问题.
Java中的内存泄露一般指未清除的引用导致的不能释放.
所以C++的内存泄露(狭义)和Java的内存泄露(广义),这个概念是不同的.

j2ee会把一所有的垃圾数据放到 大胃王 数据库中
所以不必保持大多数数据.
有些数据需要保持的比如自写的cache

删除条件很简单,
比如内存不够用了....
但你什么时间进行扫描是否够用
怎么样扫描内存总量
怎么样在多线程下锁
怎么样决定哪个元素是可以被 清掉的.
哪个元素是过期的

最重要的是以上操作怎么样让这一个周期时间缩短到下一个周期启动之前完成.


以上过程有有非常大的可能会出现内存泄露..

48 楼 ouchxp 2010-11-17  

抛出异常的爱 写道

kingkan 写道

在下的一点愚见：性能优化在于平时开发习惯的积累，新手因为知识深度面的缺乏而想不到程序高效的写法很正常，老手开发一般写出来的代码都是比较高效的，所以在开发过程中对于过于考虑性能优化是没多大必要，关键是开发前考虑的吞吐量，系统框架在I/O上瓶颈，还有热路径等，进入开发后就是代码工作啦，测试，Beta，Release，上线，维护。

不要犯错就差不多了
设计的好就不太需要考虑优化的事.
必竟j2ee又不是c
我平时很少进行coding时考虑性能问题.

+1
有问题再优化.
新手避免性能问题,就让他按规范操作就可以.(不许循环里调用数据库....XXXX)

47 楼 ouchxp 2010-11-17  

分离的北极熊 写道

看了楼上N多人的评论，你们眼中的优化是怎样的？优化完了，性能就嗷嗷好了？

但我看你们嘴里的优化，怎么那么像重构呢？能区分重构和优化么？

项目初期设计的时候就一定考虑性能问题，具体的瓶颈还在数据库，如果数据库设计的深，想的深，在后期能很好的支撑，那项目成功率问题就不大，项目是重构出来的，不是优化出来的，可以一次一次一遍一遍的重构，但你给我测试优化性能，有点扯

把String+=xx;这样的代码用StringBuffer替代，你们认为这是优化还是重构？

+1
把String+=xx;这样的代码用StringBuffer替代
1.5之后编译器会自动优化.手写StringBuffer纯属脱裤子放屁

46 楼 ouchxp 2010-11-17  

kyh23_y 写道

既然那些对象我一直在用,那为什么会被叫做是泄露?难道我用那100个对象也有错?
应该是当我没用那所有对象,或者是某些对象的时候,又没有在Map里面remove掉那些对象,导致了map一直持有引用,根据gc的原理,这样的对象是不会被回收的,这样才造成了泄露吧.这是我的理解

存在对象不代表正在使用. 已经不需要再使用的对象,但没有清除掉引用.仍然是内存泄露.
在Java中内存泄露的概念与C++不同.因为Java有自动的垃圾回收.
所以很少会有C++中的已无引用但是内存未释放的问题.
Java中的内存泄露一般指未清除的引用导致的不能释放.
所以C++的内存泄露(狭义)和Java的内存泄露(广义),这个概念是不同的.

45 楼 抛出异常的爱 2010-11-17  

kingkan 写道

在下的一点愚见：性能优化在于平时开发习惯的积累，新手因为知识深度面的缺乏而想不到程序高效的写法很正常，老手开发一般写出来的代码都是比较高效的，所以在开发过程中对于过于考虑性能优化是没多大必要，关键是开发前考虑的吞吐量，系统框架在I/O上瓶颈，还有热路径等，进入开发后就是代码工作啦，测试，Beta，Release，上线，维护。

不要犯错就差不多了
设计的好就不太需要考虑优化的事.
必竟j2ee又不是c
我平时很少进行coding时考虑性能问题.

44 楼 分离的北极熊 2010-11-17  

看了楼上N多人的评论，你们眼中的优化是怎样的？优化完了，性能就嗷嗷好了？

但我看你们嘴里的优化，怎么那么像重构呢？能区分重构和优化么？

项目初期设计的时候就一定考虑性能问题，具体的瓶颈还在数据库，如果数据库设计的深，想的深，在后期能很好的支撑，那项目成功率问题就不大，项目是重构出来的，不是优化出来的，可以一次一次一遍一遍的重构，但你给我测试优化性能，有点扯

把String+=xx;这样的代码用StringBuffer替代，你们认为这是优化还是重构？

43 楼 kingkan 2010-11-17  

在下的一点愚见：性能优化在于平时开发习惯的积累，新手因为知识深度面的缺乏而想不到程序高效的写法很正常，老手开发一般写出来的代码都是比较高效的，所以在开发过程中对于过于考虑性能优化是没多大必要，关键是开发前考虑的吞吐量，系统框架在I/O上瓶颈，还有热路径等，进入开发后就是代码工作啦，测试，Beta，Release，上线，维护。

42 楼 Mr.China 2010-11-17  

极端份子。

41 楼 xiaomogui 2010-11-17  

抛出异常的爱 写道

对于性能
1.对于新手.不要优化.
2.对于老手.建议不要优化.

？？

40 楼 xiaoyu 2010-11-17  

li445970924 写道

求一段内存泄露的代码

ThreadLocal 会有。 (http://www.0xcafefeed.com/2004/06/of-non-static-threadlocals-and-memory/)

要溢出就简单了。 大数组。


泄露的还是比较少的。 但是写出溢出的还是挺多的。

39 楼 kyh23_y 2010-11-16  

ironsabre 写道

flysnowxf 写道

ironsabre 写道

flysnowxf 写道

汗，这是很基础的概念了。
百度百科：http://baike.baidu.com/view/714962.htm

引用

当以前分配的一片内存不再需要使用或无法访问时，但是却并没有释放它，那么对于该进程来说，会因此导致总可用内存的减少，这时就出现了内存泄漏。

再说一次，向集合里一直加东西不删除，这个不叫内存泄漏。

那是你的理解了。我的理解是，分配了内存，但这些内存不再被使用，比如过期了、没用了，但又没有去删除，造成内存占用越来越多。HashMap的使用就容易出现这个问题。

哎。你这个没过期，也有用。你可以通过HashMap取出来值的，这怎么能叫泄漏呢？
我现在总是你，如果你向cache里放了100个对象，永远keep住，如果我应用程序经常来访问它，叫不叫泄漏？
如果我应用程序再也不来访问它，叫不叫泄漏？
按你的理解，第一种不叫，第二种叫。可这两种没有区别。我不可能用由第三方来判断我自己是不是泄漏，明白吗？

下面这个Stack，在被别人用的时候，可能会引起泄漏。你先找找看哪行会出总是。然后再理解一下跟你这个有什么区别。
import java.util.Arrays;
import java.util.EmptyStackException;

public class Stack {
private Object[] elements;
private int size = 0;
private static final int DEFAULT_INITIAL_CAPACITY = 16;

public Stack() {
elements = new Object[DEFAULT_INITIAL_CAPACITY];
}

public void push(Object e) {
ensureCapacity();
elements[size++] = e;
}

public Object pop() {
if (size == 0)
throw new EmptyStackException();
return elements[--size];
}

/**
* Ensure space for at least one more element, roughly doubling the capacity
* each time the array needs to grow.
*/
private void ensureCapacity() {
if (elements.length == size)
elements = Arrays.copyOf(elements, 2 * size + 1);
}
}

既然那些对象我一直在用,那为什么会被叫做是泄露?难道我用那100个对象也有错?
应该是当我没用那所有对象,或者是某些对象的时候,又没有在Map里面remove掉那些对象,导致了map一直持有引用,根据gc的原理,这样的对象是不会被回收的,这样才造成了泄露吧.这是我的理解

38 楼 maodiesky 2010-11-16  

你是给客户做东西，你问了客户是否满意吗？
别老犯程序员老毛病“自以为是”
到处折腾所谓的“性能”

37 楼 zhang_xzhi_xjtu 2010-11-16  

flysnowxf 写道

ironsabre 写道

qianhd 写道

对于新手 写的时候动动脑子 别写出内存泄漏的代码 就谢天谢地了

有些人习惯性的爱写内存泄漏的代码
真不知道怎么想的

我觉得新手想要写出内存泄漏的代码是很难的，或者说你让他写一段内存泄漏的代码他都写不出来。要不你写一个试试？

如果写本地缓存的话，是很容易出现的。比如new HashMap()，然后不断往里边put(Object)，但却不记得remove或者后台起一个线程去remove，结果hashMap里边的数据越来越多，里边引用的Object却不能被垃圾收回。这种内存泄露的情况非常普遍。

关于性能优化，在没有经验积累的情况，建议先测出来瓶颈在哪里。比如jprofile就很容易分析出哪段代码花费cpu的时间比较长。以我的经验来看，性能瓶颈主要在数据库和网络通信。

见过for里面有数据库操作的飘过。

36 楼 keshin 2010-11-16  

ironsabre 写道

flysnowxf 写道

ironsabre 写道

flysnowxf 写道

汗，这是很基础的概念了。
百度百科：http://baike.baidu.com/view/714962.htm

引用

当以前分配的一片内存不再需要使用或无法访问时，但是却并没有释放它，那么对于该进程来说，会因此导致总可用内存的减少，这时就出现了内存泄漏。

再说一次，向集合里一直加东西不删除，这个不叫内存泄漏。

那是你的理解了。我的理解是，分配了内存，但这些内存不再被使用，比如过期了、没用了，但又没有去删除，造成内存占用越来越多。HashMap的使用就容易出现这个问题。

哎。你这个没过期，也有用。你可以通过HashMap取出来值的，这怎么能叫泄漏呢？
我现在总是你，如果你向cache里放了100个对象，永远keep住，如果我应用程序经常来访问它，叫不叫泄漏？
如果我应用程序再也不来访问它，叫不叫泄漏？
按你的理解，第一种不叫，第二种叫。可这两种没有区别。我不可能用由第三方来判断我自己是不是泄漏，明白吗？

下面这个Stack，在被别人用的时候，可能会引起泄漏。你先找找看哪行会出总是。然后再理解一下跟你这个有什么区别。
import java.util.Arrays;
import java.util.EmptyStackException;

public class Stack {
private Object[] elements;
private int size = 0;
private static final int DEFAULT_INITIAL_CAPACITY = 16;

public Stack() {
elements = new Object[DEFAULT_INITIAL_CAPACITY];
}

public void push(Object e) {
ensureCapacity();
elements[size++] = e;
}

public Object pop() {
if (size == 0)
throw new EmptyStackException();
return elements[--size];
}

/**
* Ensure space for at least one more element, roughly doubling the capacity
* each time the array needs to grow.
*/
private void ensureCapacity() {
if (elements.length == size)
elements = Arrays.copyOf(elements, 2 * size + 1);
}
}

为什么类似问题总是直接照抄effective java的示例代码？