本文是我多年之前的老博客(android-performance.com)的一篇文章，老博客很久没有维护了，把一些有用的文章转移过来。

在java中，同样的方法被声明不通的类型在访问速度上会有不同吗？如果不通会有多大差异？让我们功过实验来证明这一切。

我们有下面三段代码，运算逻辑相同，我们分别用static, private, public 来声明，然后分别对他们的运行时间：

public class TestStatic {
static long add(long a, long b) {
return a + b;
}
public static void main(String[] args) {
long start = System.currentTimeMillis();
for (long i = 0; i < 9999999999L; i++) {
add(i, i + 1);
}
System.out.println(System.currentTimeMillis() - start);
}
}
public class TestPrivate {
private long add(long a, long b) {
return a + b;
}
public static void main(String[] args) {
TestPrivate obj = new TestPrivate();
long start = System.currentTimeMillis();
for (long i = 0; i < 9999999999L; i++) {
obj.add(i, i + 1);
}
System.out.println(System.currentTimeMillis() - start);
}
}
public class TestPublic {
public long add(long a, long b) {
return a + b;
}
public static void main(String[] args) {
TestPublic obj = new TestPublic();
long start = System.currentTimeMillis();
for (long i = 0; i < 9999999999L; i++) {
obj.add(i, i + 1);
}
System.out.println(System.currentTimeMillis() - start);
}
}
表1：各方法执行5次所花时间的对比结果(单位毫秒)运行环境是在我以前的旧笔记本上(Dell E6410 上)
#
static 方法
private 方法
public 方法
1
16804
20424
20428
2
17061
20291
20246
3
17044
20629
20604
4
17064
20207
21107
5
16869
20079
20405
从结果中可见，static 方法比 private 和 public 方法要快 15% 左右，private 和 public 消耗相差无几。
通过 javap -v 获得的字节码我们看到，在调用这几个方发的时候，jvm 使用了不同的指令：
static 实现中 main 方法的部分字节码：
...
6: goto 21
9: lload3
10: lload3
11: lconst1
12: ladd
13: invokestatic #27 // Method add:(JJ)J
16: pop2
17: lload3
18: lconst1
19: ladd
20: lstore3
21: lload_3
...
private 实现中 main 方法的部分字节码：
...
15: goto 35
18: aload1
19: lload 4
21: lload 4
23: lconst1
24: ladd
25: invokespecial #28 // Method add:(JJ)J
28: pop2
29: lload 4
31: lconst_1
32: ladd
33: lstore 4
35: lload 4
...
public 实现中 main 方法的部分字节码：
...
15: goto 35
18: aload1
19: lload 4
21: lload 4
23: lconst1
24: ladd
25: invokevirtual #28 // Method add:(JJ)J
28: pop2
29: lload 4
31: lconst_1
32: ladd
33: lstore 4
35: lload 4
...
在看一下几种实现方式的add方法的字节码：
static 实现中 add 方法的字节码：
static long add(long, long);
flags: ACCSTATIC
Code:
stack=4, locals=4, argssize=2
0: lload0
1: lload2
2: ladd
3: lreturn
LineNumberTable:
line 6: 0
LocalVariableTable:
Start Length Slot Name Signature
0 4 0 a J
0 4 2 b J
private 实现中 add 方法的部分字节码(需要用javap -v -p)：
private long add(long, long);
flags: ACCPRIVATE
Code:
stack=4, locals=5, argssize=3
0: lload1
1: lload3
2: ladd
3: lreturn
LineNumberTable:
line 8: 0
LocalVariableTable:
Start Length Slot Name Signature
0 4 0 this LTestPrivate;
0 4 1 a J
0 4 3 b J
public 实现中 add 方法的部分字节码：
public long add(long, long);
flags: ACCPUBLIC
Code:
stack=4, locals=5, argssize=3
0: lload1
1: lload3
2: ladd
3: lreturn
LineNumberTable:
line 6: 0
LocalVariableTable:
Start Length Slot Name Signature
0 4 0 this LTestPublic;
0 4 1 a J
0 4 3 b J
可以看到几个 add 方法字节码(Code部分)的实现几乎是一样的，而在调用这几个方法时jvm使用了 invokestatic，invokespecial 和 invokevirtual 三种不同的虚拟机指令。表1 中的性能差异主要就是由这几条指令的操作方式所决定的，invokestatic 指令是基于方法(在编译时就知道该调用哪个方法)的指令，在进行栈帧切换(可以理解方法切换)时只需要把方法的参数入栈即可，从 “static 实现中 add 方法的字节码” 中我们可以看到其 LocalVariableTable(局部变量表)中只有a、b两个值。而 invokespecial 和 invokevirtual 是基于实例的指令，他们处理把a、b两个参数入栈之外，还要把对实例的引用(this 指针)也同时入栈，所以在private和public实现方式的add方法字节码中，LocalVariableTable 还包括了this指针。所以这一点点额外的操作就决定了他们的性能差别。
更多关于字节码的解释可参考之前的一篇文章 《读懂 javap -verbose 》
关于 invokestatic 、invokespecial、invokevirtual 这几个指令的详解，可参考相关官方文档
invokespecial 和 invokevirtual 在上面的例子并没有体现出明显的差别。我们再举一个例子比较一下，在这里例子中我们引入多态特性。我们把 TestPublic 改造一下，代码如下：
class TestBaseClass {
public long add(long a, long b) {
return a + b;
}
}
public class TestPublic extends TestBaseClass {
public long add(long a, long b) {
return a + b;
}
public static void main(String[] args) {
TestBaseClass obj = new TestPublic();
long start = System.currentTimeMillis();
for (long i = 0; i < 9999999999L; i++) {
obj.add(i, i + 1);
}
System.out.println(System.currentTimeMillis() - start);
}
}
我们在执行5次，看看结果是怎样的(单位毫秒)
1
2
3
4
5
79712
80419
81648
89341
83449

在 public 多态的情况下，同样的逻辑，花的时间是之前的4倍左右。这是由于 invokevirtual 指令属于“动态绑定”——即运行时才知道方法的所属类型是哪个，相对于动态绑定的是“静态绑定”——即编译时就知道要执行的方法属于哪个类。动态绑定不仅需要查方法表，而需要在运行时确定要引用的方法所属的类到底是哪个，这两中操作是比较耗时的。

小结

本文锁讲述的内容并不会对你的实际项目有多大的性能提升，但是却可以指导我们养成一个“好”的编码习惯。对于独立的逻辑优先使用 static 方式或者是 private 方式(而且也符合面向对象的 OCP 原则)，没有必要的情况下，少用 public 方法，尤其在多态的模式下，public 方法会有比较大的性能损耗。 因为在 java 中 invokestatic 、invokespecial 都属于静态绑定，其他的静态绑定还有声明为 final 的方法，他们在编译时就知道方法属于那个类，所以在运行时会比较快地定位到方法在内存中对应的字节码地址(在方法区中)，不像动态绑定，还需要明确方法所在的类型并搜索方法表才能定位到。