关于性能优化

piao_bo_yi

浏览: 4502 次
性别:
来自: 北京

最近访客更多访客>>

博主相关

博客

微博

相册

留言

关于我

文章分类

全部博客 (2)

社区版块

存档分类

百度网络应用 JDK 编程 Cache

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

大家说说自己的看法。

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

分享到：

大型系统的挑战

2010-11-16 10:12
浏览 3249
评论(155)
论坛回复 / 浏览 (155 / 40145)
分类:编程语言
查看更多

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

ouchxp 写道

蔡华江写道

这个测试用例是错误的，因为String a = "a"+"a"就是String a = "aa";
但是String a = b + c 就不一样了。

ouchxp 写道

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

我说明了是字符串常量拼接.请看清楚再回答

aladdin181 写道

千万别用 "AAAA"+"BBBB"这样的东西来验证它的性能，那是最不能看出结果的。

恰恰是项目中有很多诸如此类的字符串常量拼接代码.

StringBuilder sql = new StringBuilder();
sql.append(" select a.col1,a.col2,a.col3 ");
sql.append(" from tablea a ,tableb b ");
sql.append(" where a.col1 = b.col1 ");

字符串常量拼接正确的做法是

String sql =  " select a.col1,a.col2,a.col3 " 
+ " from tablea a ,tableb b "
+ " where a.col1 = b.col1 ";

请不要用appand进行拼接有限行数据.
不易读.
sql这东西占不了多少内存.
不需要节约.

74 楼 ironsabre 2010-11-17

effective java中的这段代码，也不一定就有内存泄露。比如push elements[3]=e1，然后pop elements[3]，e1已经被栈弹出，不过还是被引用着，等下次push elements[3]=e2的时候，e1就没有被引用了，可以被回收。

不管是程序不能访问，还是你自己认为是过期了，这部分数据归根结底都是垃圾数据，占着茅坑不拉屎，不删除了还留着干吗？难道等内存占了4g、8g的，老板问了，怎么这么大，你难道还解释说，这些数据还可以被访问的。。。
-----------------------------------------------
需要分清我能删除还是我已经无法删除。
如果JDK里给你的Stack就是effective java里的这段，那么你在用的时候，你对很多已经垃圾了的对象是无能为力的，你很无助，你什么都做不了。我认为这种才算泄漏了。
而如果你用的是一个功能正常的HashMap，你是可以去删除你不想要的东西的。
这两种完全不一样。一种你能，一种你不能。

我希望你回答这个问题：

现在设我是被Cache住的一个小对象，我就是这个对象，那么我的身份怎么定义？

A) 我是一个Cache住的有用的对象，我能提高访问效率。
B) 我是一个被泄漏掉的垃圾，我是垃圾。

我是A还是B，谁说了算，按什么标准执行？

73 楼 flysnowxf 2010-11-17

ironsabre 写道

现在设我是被Cache住的一个小对象，我就是这个对象，那么我的身份怎么定义？

A) 我是一个Cache住的有用的对象，我能提高访问效率。
B) 我是一个被泄漏掉的垃圾，我是垃圾。

我是A还是B，谁说了算，按什么标准执行？

因为程序是你自己写的，你当然知道哪些数据是垃圾数据。比如用户session放在cache里边，用户再一次登录，以前这个session就完全没有用了。如果不去清除，很明显的结果是内存会被占光。

72 楼 ouchxp 2010-11-17

蔡华江写道

这个测试用例是错误的，因为String a = "a"+"a"就是String a = "aa";
但是String a = b + c 就不一样了。

ouchxp 写道

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

我说明了是字符串常量拼接.请看清楚再回答

aladdin181 写道

千万别用 "AAAA"+"BBBB"这样的东西来验证它的性能，那是最不能看出结果的。

恰恰是项目中有很多诸如此类的字符串常量拼接代码.

StringBuilder sql = new StringBuilder();
sql.append(" select a.col1,a.col2,a.col3 ");
sql.append(" from tablea a ,tableb b ");
sql.append(" where a.col1 = b.col1 ");

字符串常量拼接正确的做法是

String sql =  " select a.col1,a.col2,a.col3 " 
+ " from tablea a ,tableb b "
+ " where a.col1 = b.col1 ";

71 楼 ironsabre 2010-11-17

应该是常量直接相加，在编译期得到了优化处理，属于语法糖，所以看来性能很好。
但是对于变量相加，就编译期无能为力，现了原型了。性能差到不行。

70 楼 flysnowxf 2010-11-17

ironsabre 写道

哎。你这个没过期，也有用。你可以通过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);
}
}

69 楼 aladdin181 2010-11-17

string +的问题我想大家都很清楚了就是生成了N多的string 对象，这个影响性能是必然的，千万别用 "AAAA"+"BBBB"这样的东西来验证它的性能，那是最不能看出结果的。

还有楼上有位兄弟说了 JDK6 String+使用了sb，还既然他用了SB ，那么我直接用SB 实现，他怎么会比我的直接的快？他的算法比我的SB 算法高级？，有些东西只要用指头想想就明白了。

68 楼蔡华江 2010-11-17

ouchxp 写道

ironsabre 写道

ouchxp 写道

dsjt 写道

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();

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

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

如果你们的JDK版本在1.4或以下的话还说得过去.
如果是1.5或以上.
你完全可以和他提出来.你写一段测试代码给他看.执行效率有很明显的对比
反编译Class给他看.JDK已经做好优化了.自己的优化不仅多余,反而降低了执行效率

你试试我这段，再想想清楚。。
testString cost =453 mils
testStringBuilder cost =0 mils

public static void main(String[] args) {
long t1 = System.currentTimeMillis();
String str1 = "";
for (int i = 0; i < 20000; i++) {
str1 = str1 + "a";
}
long t2 = System.currentTimeMillis();
System.out.println("testString cost =" + (t2 - t1) + " mils");

long t3 = System.currentTimeMillis();
StringBuilder sb = new StringBuilder("");
for (int i = 0; i < 20000; i++) {
sb.append("a");
}
long t4 = System.currentTimeMillis();
System.out.println("testStringBuilder cost =" + (t4 - t3) + " mils");

}

你试试我这段, 再想想清楚.

我可没说循环也不用StringBuilder

	public static void main(String[] args) {
		long t1 = System.currentTimeMillis();
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < 1000000; i++) {
			//15个a
			String str = "a" + "a" + "a" + "a" + "a" + "a" + "a" + "a" + "a"
					+ "a" + "a" + "a" + "a" + "a" + "a";
			sb.append(str);
		}
		long t2 = System.currentTimeMillis();
		System.out.println("testString cost =" + (t2 - t1) + " mils");

		long t3 = System.currentTimeMillis();
		StringBuilder sb1 = new StringBuilder("");
		for (int i = 0; i < 1000000; i++) {
			sb1.append("a");//15个a
			sb1.append("a");
			sb1.append("a");
			sb1.append("a");
			sb1.append("a");
			sb1.append("a");
			sb1.append("a");
			sb1.append("a");
			sb1.append("a");
			sb1.append("a");
			sb1.append("a");
			sb1.append("a");
			sb1.append("a");
			sb1.append("a");
			sb1.append("a");
		}
		long t4 = System.currentTimeMillis();
		System.out.println("testStringBuilder cost =" + (t4 - t3) + " mils");
	}

这个测试用例是错误的，因为String a = "a"+"a"就是String a = "aa";
但是String a = b + c 就不一样了。

67 楼 ouchxp 2010-11-17

ironsabre 写道

ouchxp 写道

dsjt 写道

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();

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

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

你试试我这段, 再想想清楚.

我可没说循环也不用StringBuilder

	public static void main(String[] args) {
		long t1 = System.currentTimeMillis();
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < 1000000; i++) {
			//15个a
			String str = "a" + "a" + "a" + "a" + "a" + "a" + "a" + "a" + "a"
					+ "a" + "a" + "a" + "a" + "a" + "a";
			sb.append(str);
		}
		long t2 = System.currentTimeMillis();
		System.out.println("testString cost =" + (t2 - t1) + " mils");

		long t3 = System.currentTimeMillis();
		StringBuilder sb1 = new StringBuilder("");
		for (int i = 0; i < 1000000; i++) {
			sb1.append("a");//15个a
			sb1.append("a");
			sb1.append("a");
			sb1.append("a");
			sb1.append("a");
			sb1.append("a");
			sb1.append("a");
			sb1.append("a");
			sb1.append("a");
			sb1.append("a");
			sb1.append("a");
			sb1.append("a");
			sb1.append("a");
			sb1.append("a");
			sb1.append("a");
		}
		long t4 = System.currentTimeMillis();
		System.out.println("testStringBuilder cost =" + (t4 - t3) + " mils");
	}

66 楼 ironsabre 2010-11-17

ouchxp 写道

dsjt 写道

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();

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

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

你这段代码确实String+和StringBuilder看来效果差不多，或才说String+还快一点点。
但是你要清楚为什么。
这是因为你这两个方法生成的对象的数量是一样的，所以你这个例子很有欺骗性。
你要明白，之所以性能差别很大，最主要的就是String+在大多数情况下会多生成很多临时对象来。

下面这个例子，String+的性能会差上几千倍。

public static void main(String[] args) {
long t1 = System.currentTimeMillis();
String str1 = "";
for (int i = 0; i < 20000; i++) {
str1 = str1 + "a";
}
long t2 = System.currentTimeMillis();
System.out.println("testString cost =" + (t2 - t1) + " mils");

long t3 = System.currentTimeMillis();
StringBuilder sb = new StringBuilder("");
for (int i = 0; i < 20000; i++) {
sb.append("a");
}
long t4 = System.currentTimeMillis();
System.out.println("testStringBuilder cost =" + (t4 - t3) + " mils");

}

65 楼 ironsabre 2010-11-17

64 楼 aladdin181 2010-11-17

性能这个问题从设计到开发到测试都是需要考虑和验证的，不是说开发完了通过测试来找问题，LZ的观点偏了

63 楼蔡华江 2010-11-17

ironsabre 写道

蔡华江写道

ironsabre 写道

蔡华江写道

ironsabre 写道

flysnowxf 写道

ironsabre 写道

flysnowxf 写道

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

引用

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

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

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

你这个封装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的内存并没有释放，这不是溢出，这是泄漏。

你是无法拿到Stack中Object[]的引用的。但请你告诉我，你为什么无法拿到Cache里的值呢。

这个。。。。

62 楼 ironsabre 2010-11-17

蔡华江写道

ironsabre 写道

蔡华江写道

ironsabre 写道

flysnowxf 写道

ironsabre 写道

flysnowxf 写道

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

引用

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

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

你是无法拿到Stack中Object[]的引用的。
但请你告诉我，你无法存取删除Cache里的值呢。如果你能存取Cache里的东西，你也能去删除掉它，这叫什么泄漏？
或者你告诉我们，我们要怎么理解一个在Cache里的东西是属于正常的需要被Cache的还是属于泄漏的呢？

61 楼 ironsabre 2010-11-17

60 楼 ironsabre 2010-11-17

ouchxp 写道

dsjt 写道

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();

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

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

59 楼 ironsabre 2010-11-17

指尖帝写道

bitray 写道

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

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

变量拼接还是很有问题的。JDK 1.6下。
testString cost =453 mils
testStringBuilder cost =0 mils

public static void main(String[] args) {
long t1 = System.currentTimeMillis();
String str1 = "";
for (int i = 0; i < 20000; i++) {
str1 = str1 + "a";
}
long t2 = System.currentTimeMillis();
System.out.println("testString cost =" + (t2 - t1) + " mils");

StringBuilder sb = new StringBuilder("");
long t3 = System.currentTimeMillis();
for (int i = 0; i < 20000; i++) {
sb.append("a");
}
long t4 = System.currentTimeMillis();
System.out.println("testStringBuilder cost =" + (t4 - t3) + " mils");

}

58 楼 ouchxp 2010-11-17

指尖帝写道

bitray 写道

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

+1
尤其是字符串常量拼接+的性能要大大好于StringBuilder

57 楼 ouchxp 2010-11-17

dsjt 写道

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();

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

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

56 楼 nepalon 2010-11-17

象string和stringbuffer这些应该是养成一个编程习惯，单纯的String str = "a"+"b"+"c"换成stringbuffer意义也不大，但是如果通过一个循环来拼一个string，那stringbuffer还有点作用（有两年多没用java了，新的java1.6有没有优化就不清楚了）。其实性能问题更多的是由设计引起的，比如要获取一个列表的记录总数怎样实现（select count(0) from tablename吗？）、怎样实现翻页这些都会存在性能问题。如果从纯技术角度，那优化DB的回报是最高的，比如对查询语句建索引（建索引提升一两个数量级的速度是很正常的）。一般的性能问题通常发生在DB服务器，应用服务器只要不内存泄漏的话，一般不会有什么太大问题的。

« 上一页 1 2 3 4 5 6 7 8 下一页 »

发表评论

您还没有登录,请您登录后再发表评论

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论