java - 为什么代理模式这么慢？

Question

至少在 java 中，代理模式有很多开销——我不记得确切的数字，但是当包装微小的方法时，代理所花费的时间大约是包装方法的 50 倍。例如，这就是为什么 java.awt.image.BufferedImage.setRGB 和 getRGB 真的慢；大约有三个代理包装实际的 byte[]。

为什么 50 次？!为什么代理不只是加倍时间？

---

编辑:=(

对于 SO 来说，这似乎很常见，我得到了一堆答案，告诉我我的问题是错误的。它不是。查看 BufferedImage 或其他一些真正的代理模式，而不是那些微基准测试。事实上，如果你必须对 BufferedImage 进行大量像素操作并且你知道它的结构，你可以通过手动取消代理来实现上述巨大的加速；见this answer .

哦，还有here's我的 50 倍来源。正如本文所详述的那样，代理在包装需要很长时间时不会有明显的损失，但是如果您包装的是一个小方法，它们确实会产生重大的痛苦开销。

Answer 1

我不知道“50 倍”这个数字从何而来，但它很可疑。可能是一个特定的代理明显比它所代理的慢，这取决于他们每个人在做什么，但是从中概括地说“代理模式太慢了”是逻辑上非常戏剧化且备受质疑的飞跃。

试试这个:

Thingy.java:

public class Thingy
{
    public int foo(int param1, int param2)
    {
        return param2 - param1;
    }
}

ThingyProxy.java:

public class ThingyProxy
{
    Thingy thingy;

    public ThingyProxy()
    {
        this.thingy = new Thingy();
    }

    public int foo(int param1, int param2)
    {
        return this.thingy.foo(param1, param2);
    }
}

WithoutProxy.java:

public class WithoutProxy
{
    public static final void main(String[] args)
    {
        Thingy t;
        int sum;
        int counter;
        int loops;

        sum = 0;
        t = new Thingy();
        for (loops = 0; loops < 300000000; ++loops) {
            sum = 0;
            for (counter = 0; counter < 100000000; ++counter) {
                sum += t.foo(1, 2);
            }
            if (sum != 100000000) {
                System.out.println("ERROR");
                return;
            }
        }
        System.exit(0);
    }
}

WithProxy.java:

public class WithProxy
{
    public static final void main(String[] args)
    {
        ThingyProxy t;
        int sum;
        int counter;
        int loops;

        sum = 0;
        t = new ThingyProxy();
        for (loops = 0; loops < 300000000; ++loops) {
            sum = 0;
            for (counter = 0; counter < 100000000; ++counter) {
                sum += t.foo(1, 2);
            }
            if (sum != 100000000) {
                System.out.println("ERROR");
                return;
            }
        }
        System.exit(0);
    }
}

在我的机器上简单试用:

$ time java WithoutProxy real    0m0.894suser    0m0.900ssys     0m0.000s$ time java WithProxyreal    0m0.934suser    0m0.940ssys     0m0.000s$ time java WithoutProxy real    0m0.883suser    0m0.850ssys     0m0.040s$ time java WithProxyreal    0m0.937suser    0m0.920ssys     0m0.030s$ time java WithoutProxy real    0m0.898suser    0m0.880ssys     0m0.030s$ time java WithProxyreal    0m0.936suser    0m0.950ssys     0m0.000s

稍微慢一点？是的。慢 50 倍？没有。

现在，为 JVM 计时是众所周知的困难，像上面这样的简单实验必然值得怀疑。但我认为可能会出现 50 倍的差异。

编辑:我应该提到上面的循环数量非常非常少，发布的数字如下:

real    0m0.058suser    0m0.040ssys     0m0.020s

...这让您了解虚拟机在环境中的启动时间。例如，上面的时间主要不是 VM 启动，实际执行时间只有一微秒的差异，它们主要是执行时间。