潦草白纸

品味性能之道<十一>：JAVA中switch和if性能比较

通常而言大家普遍的认知里switch case的效率高于if else。根据我的理解而言switch的查找类似于二叉树，if则是线性查找。按照此逻辑推理对于对比条件数目大于3时switch更优，并且对比条件数目越多时switch的优势越为明显。

 

一、测试目的

最近与开发同学对于前面提到的性能问题，有着各自不同的见解，为证明我的观点，现设计如下测试场景验证

PS：一个方法里多达65个if else

 

二、测试策略
利用Junit4执行本次测试，分别设计50个、70个、100个条件式测试，每轮测试分别执行1千万、2千万、3千万、4千万、5千万和6千万次，为了力求让每轮测试不受外部因素干扰每轮测试执行10次收集信息分析。
为了让java在纯净的环境中运行。同时关闭了QQ、360、chrome等应用软件。 

三、测试环境
  • Java 版本信息
Java version "1.7.0_25"
Java(TM) SE Runtime Environment (build 1.7.0_25-b17)
Java HotSpot(TM) 64-Bit Server VM (build 23.25-b01, mixed mode)
Junit4
  • JVM配置信息
--launcher.XXMaxPermSize
256m
-Dosgi.requiredJavaVersion=1.6
-Xms512m
-Xmx1024m
  • 系统信息
Windows7 旗舰版
64位操作系统
  • 设备信息
处理器：Intel(R) Core(TM) i3-2328M CPU @ 2.20GHz 2.20 GHz
安装内存(RAM)：4.00GB (3.90 GB 可用)
因此次不涉及硬盘读写，故不记录硬盘信息

四、测试脚本
        因篇幅所限，测试脚本略有缩减。
 1 import java.util.Calendar;
 2 import java.util.GregorianCalendar;
 3 import java.util.Random;
 4 import org.junit.After;
 5 import org.junit.Before;
 6 import org.junit.Test;
 7 public class ServerServiceTest {
 8  Calendar calender_begin, calender_end;
 9  Long time_begin, time_end; //记录测试开始时间，结束时间
10  int flagNumber = 1000000;// 迭代数
11  Random r = new Random();
12  int i = new Random().nextInt(100);//生成随机种子
13  @Before
14  public void setUp() throws Exception {
15   calender_begin = new GregorianCalendar();
16   time_begin = calender_begin.getTimeInMillis();
17  }
18  @After
19  public void tearDown() throws Exception {
20   calender_end = new GregorianCalendar();
21   time_end = calender_end.getTimeInMillis();
22   System.out.println(time_end - time_begin);
23  }
24  @Test
25  public void ifTest() {
26   for (int temp = 0; temp < flagNumber; temp++) {
27    i = r.nextInt(100);
28    if (i == 0) {
29    } else if (i == 1) {
30    } else if (i == 2) {
31    } else if (i == 3) {
32    } else if (i == 4) {
33    } else if (i == 5) {
34    } else if (i == 6) {
35    } else if (i == 7) {
36    } else if (i == 8) {
37    } else if (i == 9) {
38    } else if (i == 10) {
39    } 
40   }
41  }
42  @Test
43  public void switchTest() throws InterruptedException {
44   for (int temp = 0; temp < flagNumber; temp++) {
45    i = r.nextInt(100);
46    switch (i) {
47    case 0:
48     break;
49    case 1:
50     break;
51    case 2:
52     break;
53    case 3:
54     break;
55    case 4:
56     break;
57    case 5:
58     break;
59    default:
60     break;
61    }
62   }
63  }
64 }
View Code 
五、测试结果
        以下是收集的测试数据，时间单位毫秒（ms）。其实这种数据看起来很难看出问题所在。
        
条件式测试数 迭代数 　 1
(ms)
 2 3 4 5 6 7 8 9 10 avg max min
100 6千万 if 469 466 474 455 477 478 466 460 464 483 469 483 455
switch 443 443 441 438 443 437 441 442 439 438 441 443 437
5千万 if 399 420 394 403 408 402 403 393 410 430 406 430 393
switch 367 374 370 366 374 382 381 376 373 397 376 397 366
4千万 if 344 325 326 359 320 325 324 319 319 328 329 359 319
switch 302 305 300 315 302 302 298 318 297 300 304 318 297
3千万 if 255 249 240 248 249 247 250 256 251 246 249 256 240
switch 228 232 227 231 230 229 227 231 228 231 229 232 227
2千万 if 211 177 183 182 181 172 174 170 175 178 180 211 170
switch 165 149 155 152 154 155 155 166 151 158 156 166 149
1千万 if 179 174 176 176 169 177 176 191 173 183 177 191 169
switch 152 156 167 161 158 151 161 161 159 161 159 167 151
70 6千万 if 424 416 440 437 427 419 417 411 416 429 424 440 411
switch 389 395 387 388 388 392 397 391 392 393 391 397 387
5千万 if 368 366 352 354 351 352 350 362 355 361 357 368 350
switch 327 327 326 324 328 327 324 323 330 325 326 330 323
4千万 if 321 300 295 293 284 283 281 335 276 281 295 335 276
switch 259 262 260 262 259 261 259 268 260 267 262 268 259
3千万 if 219 229 226 217 220 226 215 223 217 226 222 229 215
switch 199 197 203 199 199 199 197 200 200 197 199 203 197
2千万 if 149 158 152 155 177 159 159 158 161 150 158 177 149
switch 136 136 132 134 145 133 133 132 136 133 135 145 132
1千万 if 86 83 87 81 90 88 77 83 95 85 86 95 77
switch 65 67 67 67 68 71 67 68 68 68 68 71 65
50 6千万 if 374 361 363 363 362 364 376 366 372 373 367 376 361
switch 347 343 341 341 338 362 340 343 343 343 344 362 338
5千万 if 324 312 306 306 341 312 312 299 307 307 313 341 299
switch 289 287 285 283 291 288 290 288 290 281 287 291 281
4千万 if 287 247 251 252 265 247 248 256 252 256 256 287 247
switch 239 237 236 229 243 230 235 232 228 228 234 243 228
3千万 if 193 196 195 197 203 198 201 188 200 204 198 204 188
switch 184 178 181 175 173 172 176 184 193 174 179 193 172
2千万 if 128 129 133 145 133 139 139 130 131 143 135 145 128
switch 117 118 118 117 115 120 114 113 116 118 117 120 113
1千万 if 81 68 82 75 76 68 69 79 91 75 76 91 68
switch 60 57 60 60 59 65 59 62 61 60 60 65 57

六、测试结果分析
        纯数据的测试结果，很难进行分析，经过整理以后如下图：
        
 
        if-100为if执行100条件式测试数，switch-100为switch执行100条件式测试数；
        根据此图表结果，大家已经可能很清晰的看出If与Swtich的性能对比结果了。但是如此细微的性能差异，实现了业务就行了，何必关注这种费心又麻烦的事呢？
        哈哈哈，性能测试更多时候，也是沟通问题，更是行政问题。

 

 
七、总结
        这次验证过程，其实就是一次简单的性能测试过程，也就是——需求挖掘->明确目的->设计策略->准备环境->脚本编写->收集数据->结果分析->测试报告。此处略去的报告内容，因为不需要什么报告了。哈哈哈！（大家懂的）
        就大量条件式的业务场景而言，除了利用switch以外，其实还可以用到枚举(enum)作为条件式，抽象每个判断式导向为函数式(function)。可能哪天我心情好会把利用enum优化的代码给放出来。
 
2015-8-23 15:17:18 跟新
策略模式+接口注入，写的是伪代码没有严格的语法规范，大家凑合着看。
interface Service{
	
	public void execute();

	public <T> T eval();
}


public class Strategy{

	private static Concrunthashmap<String,function> content = new Concrunthashmap<String,function>();

	public void register(String name,Clas<T> xxx){
		if(!content.has(name)){
			content.put(xxx);//这里隐去了反射生成对象的过程
		}
	}

	public void execute(String name){
		content.get(name).execute();
	}

	public void eval(String name){
		content.get(name).eval();
	}
}

class HelloServiceImpl implements Service{

	public void execute(){
		print "hello world";
	}

	public String eval(){
		return "hello world";
	}
}

class HiServiceImpl implements Service{

	public void execute(){
		print "hi world";
	}

	public String eval(){
		return "hi world";
	}
}

 

 

posted on 2014-01-01 19:58  潦草白纸  阅读(9160)  评论(0)  编辑  收藏  举报

导航