final 修饰方法能提升 Java 性能吗

对于这个问题，有两种答案：

• 正方：有文章持肯定答案，甚至说能提升 50%，并将其作为提升程序性能的建议之一；
• 反方：有文章认为这是没有必要的，因为 JVM 会对这方面做优化，所以这么做是多此一举。

众说纷纭，都是一家之言，都没有理论支撑。

今天特地做了个对比试验，一探究竟。

1. 试验配置

JDK 1.8，Eclipse Neon Milestone 1 (4.6.0M1)，Android Studio 1.5.1。

性能，主要包括占用内存和执行时间。本实验验证 final 方法是否对执行时间有影响。

具体方法为：同一个类中定义两个方法，一个为 final，另一个为 non final。分别调用 MAX 次，比较其耗时。如果 final 方法的耗时更少，则说明 final 能提高性能，否则不能。

2. 试验代码

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        long MAX = 10000000;
        int times = 100;

        // non-final
        System.out.println("f:");
        for (int k = 0; k < times; k++) {
            long start = System.currentTimeMillis();
            for (int i = 0 ; i < MAX; i++) {
                main.m();
            }
            long end = System.currentTimeMillis();

            System.out.println("" + (end - start));
        }

        // final
        System.out.println("\n\nfm:");
        for (int k = 0; k < times; k++) {
            long start1 = System.currentTimeMillis();
            for (int i = 0 ; i < MAX; i++) {
                main.fm();
            }
            long end1 = System.currentTimeMillis();

            System.out.println("" + (end1 - start1));
        }

    }


    private void m() {
    }

    private final void fm() {
    }
}

将上述两个方法和统计代码嵌入 Fragment 中的 onCreate() 方法中运行。

在 Eclipse 和 Android Studio 上运行时 MAX 的值分别为：10^9和10^7。

3. 试验结果

Eclipse 下：

non-final   final
464 467
460 463
461 464
471 450
464 461
476 469
462 457
449 458
458 468
467 458
464 464
475 451
472 464
456 454
463 461
465 463
461 464
544 458
490 460
470 452
459 453
466 453
541 463
473 457
460 458
449 464
455 464
471 634
578 467
499 457
481 459
472 454
656 469
476 477
460 470
468 462
459 464
455 464
455 472
461 454
476 452
462 449
499 452
480 463
482 451
473 461
526 459
477 463
465 458
465 483
451 476
460 457
458 462
477 457
477 451
456 467
454 467
463 470
466 454
459 466
461 458
458 467
466 493
457 453
458 454
459 456
465 466
467 452
463 454
461 464
469 460
477 461
459 474
468 465
479 467
457 467
461 454
454 461
459 460
463 461
457 458
473 466
455 454
465 455
455 455
454 474
447 457
454 463
454 460
456 454
458 448
466 460
458 464
464 453
467 461
465 536
462 507
450 476
469 461
476 464

Android 下：

non-final     final
265 257
246 263
255 265
254 252
252 282
259 259
252 248
259 254
266 310
258 285
260 268
257 264
287 276
250 261
260 299
241 254
265 280
248 264
265 274
265 263
272 253
257 272
255 314
261 276
248 287
257 267
254 267
262 259
250 251
247 276
257 256
260 266
262 265
266 268
255 271
243 279
262 250
248 247
283 279
253 290
254 282
257 254
282 258
272 268
273 256
257 267
259 287
246 286
250 260
247 268
257 257
257 284
268 256
252 277
258 260
240 269
247 265
263 254
256 256
265 246
240 260
259 263
260 267
268 255
260 269
258 260
253 261
254 267
248 258
247 266
260 256
265 273
261 242
264 258
256 260
259 265
265 268
272 256
267 264
278 253
265 272
269 262
261 269
260 261
261 283
259 271
270 270
261 259
265 258
254 284
268 271
250 259
273 256
266 261
258 264
263 266
265 263
259 250
248 263
257 256

4. 结论

是否使用 final 修饰方法跟缩短程序的执行时间没有必然联系。

我的试验设置有纰漏之处？希望有大神看到该文章，能够从理论上给该问题一个结论，提前谢过。

5. 一点联想

与 final 类似，如果将方法声明为 static，会提高程序的性能吗？