Java 静态调用比非静态调用更昂贵还是更便宜？

Question

是否有这样或那样的性能优势？它是编译器/VM 特定的吗？我正在使用热点。

Answer 1

四年后...

好吧，为了一劳永逸地解决这个问题，我编写了一个基准测试，它显示了不同类型的调用（虚拟的、非-虚拟的、静态的）相互比较。

我在 ideone 上运行了它，这就是我得到的结果：（

迭代次数越大越好。）

    Success time: 3.12 memory: 320576 signal:0
  Name          |  Iterations
    VirtualTest |  128009996
 NonVirtualTest |  301765679
     StaticTest |  352298601
Done.

正如预期的那样，虚拟方法调用是最慢，非虚方法调用更快，静态方法调用更快。

我没想到的是差异如此明显：虚拟方法调用的运行速度不到非虚拟方法调用速度的一半，而非虚拟方法调用的运行速度又被测量为运行整个<比静态调用慢strong>15%。这就是这些测量结果所显示的；事实上，实际的差异必须稍微更加明显，因为对于每个虚拟、非虚拟和静态方法调用，我的基准测试代码都有一个额外的常量开销，即递增一个整数变量、检查布尔变量，如果不成立则循环。

我想结果会因 CPU 和 JVM 的不同而不同，因此请尝试一下，看看您会得到什么：

import java.io.*;

class StaticVsInstanceBenchmark
{
    public static void main( String[] args ) throws Exception
    {
        StaticVsInstanceBenchmark program = new StaticVsInstanceBenchmark();
        program.run();
    }

    static final int DURATION = 1000;

    public void run() throws Exception
    {
        doBenchmark( new VirtualTest( new ClassWithVirtualMethod() ), 
                     new NonVirtualTest( new ClassWithNonVirtualMethod() ), 
                     new StaticTest() );
    }

    void doBenchmark( Test... tests ) throws Exception
    {
        System.out.println( "  Name          |  Iterations" );
        doBenchmark2( devNull, 1, tests ); //warmup
        doBenchmark2( System.out, DURATION, tests );
        System.out.println( "Done." );
    }

    void doBenchmark2( PrintStream printStream, int duration, Test[] tests ) throws Exception
    {
        for( Test test : tests )
        {
            long iterations = runTest( duration, test );
            printStream.printf( "%15s | %10d\n", test.getClass().getSimpleName(), iterations );
        }
    }

    long runTest( int duration, Test test ) throws Exception
    {
        test.terminate = false;
        test.count = 0;
        Thread thread = new Thread( test );
        thread.start();
        Thread.sleep( duration );
        test.terminate = true;
        thread.join();
        return test.count;
    }

    static abstract class Test implements Runnable
    {
        boolean terminate = false;
        long count = 0;
    }

    static class ClassWithStaticStuff
    {
        static int staticDummy;
        static void staticMethod() { staticDummy++; }
    }

    static class StaticTest extends Test
    {
        @Override
        public void run()
        {
            for( count = 0;  !terminate;  count++ )
            {
                ClassWithStaticStuff.staticMethod();
            }
        }
    }

    static class ClassWithVirtualMethod implements Runnable
    {
        int instanceDummy;
        @Override public void run() { instanceDummy++; }
    }

    static class VirtualTest extends Test
    {
        final Runnable runnable;

        VirtualTest( Runnable runnable )
        {
            this.runnable = runnable;
        }

        @Override
        public void run()
        {
            for( count = 0;  !terminate;  count++ )
            {
                runnable.run();
            }
        }
    }

    static class ClassWithNonVirtualMethod
    {
        int instanceDummy;
        final void nonVirtualMethod() { instanceDummy++; }
    }

    static class NonVirtualTest extends Test
    {
        final ClassWithNonVirtualMethod objectWithNonVirtualMethod;

        NonVirtualTest( ClassWithNonVirtualMethod objectWithNonVirtualMethod )
        {
            this.objectWithNonVirtualMethod = objectWithNonVirtualMethod;
        }

        @Override
        public void run()
        {
            for( count = 0;  !terminate;  count++ )
            {
                objectWithNonVirtualMethod.nonVirtualMethod();
            }
        }
    }

    static final PrintStream devNull = new PrintStream( new OutputStream() 
    {
        public void write(int b) {}
    } );
}

值得注意的是，这种性能差异仅适用于除了调用无参数方法之外不执行任何操作的代码。无论调用之间有什么其他代码，都会淡化差异，其中包括参数传递。实际上，静态调用和非虚拟调用之间 15% 的差异可能可以通过以下事实来解释：this 指针不必传递给静态方法。因此，只需要在调用之间使用相当少量的代码做一些琐碎的事情，就可以将不同类型的调用之间的差异稀释到没有任何净影响的程度。

此外，虚拟方法调用的存在是有原因的；它们确实有服务的目的，并且它们是使用底层硬件提供的最有效的手段来实现的。 （CPU 指令集。）如果您希望通过用非虚拟或静态调用替换它们来消除它们，您最终必须添加尽可能多的额外代码来模拟它们的功能，那么您产生的净开销是必然的不是更少，而是更多。很可能，很多，很多，难以想象的很多，更多。

Answer 2

首先：您不应该根据性能来选择静态与非静态。

第二：在实践中，这不会有任何区别。 Hotspot 可能会选择优化方式，使一种方法的静态调用更快，另一种方法的非静态调用更快。

第三：围绕静态与非静态的许多神话要么基于非常古老的 JVM（它没有像 Hotspot 那样进行优化），要么基于一些关于 C++ 的记忆琐事（其中动态调用使用一个 比静态调用更多的内存访问）。

Answer 3

那么，静态调用不能被覆盖（因此始终是内联的候选者），并且不需要任何无效检查。 HotSpot 对实例方法进行了一系列很酷的优化，这很可能会抵消这些优点，但它们是静态调用可能更快的可能原因。

然而，这不应该影响您的设计 - 以最易读、最自然的方式编写代码 - 并且只有在您有正当理由时才担心这种微优化（您几乎永远不会）。

Answer 4

7 年后...

我对 Mike Nakis 发现的结果没有很大的信心，因为它们没有解决与热点优化相关的一些常见问题。我使用 JMH 进行了基准测试，发现与静态调用相比，实例方法在我的机器上的开销约为 0.75%。鉴于开销较低，我认为除了对延迟最敏感的操作之外，它可以说不是应用程序设计中最大的问题。我的 JMH 基准测试的总结结果如下：

java -jar target/benchmark.jar

# -- snip --

Benchmark                        Mode  Cnt          Score         Error  Units
MyBenchmark.testInstanceMethod  thrpt  200  414036562.933 ± 2198178.163  ops/s
MyBenchmark.testStaticMethod    thrpt  200  417194553.496 ± 1055872.594  ops/s

你可以在 Github 上查看代码；

https://github.com/nfisher/svsi

基准测试本身非常简单，但旨在最大限度地减少死代码消除和不断折叠。我可能错过/忽略了其他优化，并且这些结果可能会因 JVM 版本和操作系统的不同而有所不同。

package ca.junctionbox.svsi;

import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.infra.Blackhole;

class InstanceSum {
    public int sum(final int a, final int b) {
        return a + b;
    }
}

class StaticSum {
    public static int sum(final int a, final int b) {
        return a + b;
    }
}

public class MyBenchmark {
    private static final InstanceSum impl = new InstanceSum();

    @State(Scope.Thread)
    public static class Input {
        public int a = 1;
        public int b = 2;
    }

    @Benchmark
    public void testStaticMethod(Input i, Blackhole blackhole) {
        int sum = StaticSum.sum(i.a, i.b);
        blackhole.consume(sum);
    }

    @Benchmark
    public void testInstanceMethod(Input i, Blackhole blackhole) {
        int sum = impl.sum(i.a, i.b);
        blackhole.consume(sum);
    }
}

Answer 5

它是编译器/VM 特定的。

• 理论上可以进行静态调用
  效率稍高一些，因为它
  不需要做虚函数
  查找，也可以避免
  隐藏的“这个”的开销
  范围。
• 在实践中，许多编译器会
  无论如何优化这个。

因此，除非您已将其确定为应用程序中真正关键的性能问题，否则可能不值得担心。过早的优化是万恶之源等...

但是，我已经看到这种优化在以下情况下可以显着提高性能：

• 方法执行非常简单的数学计算，无需内存访问
• 方法被调用<在紧密的内循环 CPU 密集型应用程序中每秒数百万次
• ，其中每一点性能都很重要

如果上述内容适用于您，则可能值得测试。

使用静态方法还有另一个好的（并且可能更重要！）的原因 - 如果该方法实际上具有静态语义（即逻辑上没有连接到类的给定实例），那么将其设为静态是有意义的来反映这一事实。经验丰富的 Java 程序员会注意到 static 修饰符并立即想到“啊哈！这个方法是静态的，因此它不需要实例，并且可能不会操纵实例特定的状态”。所以你将有效地传达了该方法的静态性质......

Answer 6

正如之前的发帖者所说：这似乎是一个不成熟的优化。

但是，有一个区别（部分来自非静态调用需要将被调用者对象额外推送到操作数堆栈上）：

由于静态方法无法被覆盖，因此不会有任何虚拟方法在运行时查找静态方法调用。在某些情况下，这可能会导致明显的差异。

字节码级别的区别在于，非静态方法调用是通过 INVOKEVIRTUAL，INVOKEINTERFACE 或 INVOKESPECIAL 而静态方法调用是通过 INVOKESTATIC。

Answer 7

令人难以置信的是，静态调用与非静态调用的性能差异不太可能对您的应用程序产生影响。请记住“过早的优化是万恶之源”。

Answer 8

对于决定方法是否应该是静态的，性能方面应该是无关紧要的。如果您遇到性能问题，将大量方法设为静态并不能挽救局面。也就是说，静态方法几乎肯定不比任何实例方法慢，在大多数情况下稍快：

1.) 静态方法不是多态的，因此 JVM 的决策较少make 找到要执行的实际代码。这是 Hotspot 时代的一个有争议的问题，因为 Hotspot 将优化只有一个实现站点的实例方法调用，因此它们将执行相同的操作。

2.) 另一个微妙的区别是静态方法显然没有“this”引用。这会导致堆栈帧比具有相同签名和主体的实例方法小一个槽（“this”被放置在字节码级别的局部变量的槽 0 中，而对于静态方法，槽 0 用于第一个槽）方法的参数）。

Answer 9

理论上来说，更便宜。

即使您创建了对象的实例，静态初始化也会完成，而静态方法不会执行通常在构造函数中完成的任何初始化。

不过，我还没有测试过这个。

Answer 10

正如 Jon 指出的那样，静态方法无法被重写，因此在足够简单的 Java 运行时调用静态方法可能比调用实例方法更快。

但是，即使假设您正在关心弄乱您的设计以节省几纳秒，这也会带来另一个问题：您是否需要重写自己的方法？如果您更改代码以将实例方法变成静态方法，以节省一纳秒，然后在此基础上实现您自己的调度程序，那么您的调度程序几乎肯定会比构建的调度程序效率低已经进入您的 Java 运行时了。

Answer 11

我想在这里添加其他很好的答案，这也取决于您的流程，例如：

Public class MyDao {

   private String sql = "select * from MY_ITEM";

   public List<MyItem> getAllItems() {
       springJdbcTemplate.query(sql, new MyRowMapper());
   };
};

请注意，每次调用都会创建一个新的 MyRowMapper 对象。
相反，我建议在这里使用静态字段。

Public class MyDao {

   private static RowMapper myRowMapper = new MyRowMapper();
   private String sql = "select * from MY_ITEM";

   public List<MyItem> getAllItems() {
       springJdbcTemplate.query(sql, myRowMapper);
   };
};