Question

我正在制作一个简单的游戏，它有一个名为Game的类的单个实例，可以处理游戏的所有逻辑。

项目中的许多类都有一个名为tick()的方法，该方法在Game实例中每秒调用60次并处理更新信息。此类实例存储在Game类的列表中。

此方法需要访问Game类，目前看起来像这样：

MyClass {
    public void tick(Game game) {
        ...
    }
}

我的问题是 - 我现在正在做什么更好并且每秒将参考数百次传递给所有需要它的实例，或者简单地将一个引用传递给创建这些实例并使类看起来像这样：

MyClass {
    private Game game;
    public MyClass(Game game) { this.game = game }
    public void tick() { ... }
}

基本上，每秒多次传递此引用是多么费力？

提前致谢。

修改也许另一个选择是将Game类的所有必需成员标记为静态，并在没有引用的情况下将其称为这样的成员？

Answer 1

这不是那么费力。你应该根据设计做出决定，而不是速度。

游戏是否通过了变化？如果没有，最好在构造函数中传递它，并为了清晰起见使字段最终。

但是，有很多游戏吗？如果是这样，在方法中传递它可能是有意义的，这样你就不必构造大量的MyClass - 你可以只用一个来制作它（或许）。

Answer 2

在您发现这是一个瓶颈之前请先了解一下。我认为这对你的计划来说并不重要。

但缺点是MyClass占用的内存如果有游戏作为成员会增加。如果您要创建大量 MyClass ，您的程序将使用更多内存。

Answer 3

您可能需要对此进行分析以获得明确的答案。您正在平衡将参数推入堆栈并访问函数内部的参数与从函数内访问实例字段的成本。我的猜测是，这将接近洗涤。

如果game在执行期间改变了身份，那么每次都将它作为参数传递是一个巨大的胜利。但是，这听起来不适用于您的情况。

Answer 4

我确信没有（或极少）征税但决定验证这一事实。这是我的代码：

public class Test {
    public static void main(String[] args) {
        Test t = new Test();

        long before = System.currentTimeMillis();
        for (int i = 0;  i < 10000000;  i++) {
            t.foo();
        }
        long after = System.currentTimeMillis();
        System.out.println("no args: " + (after - before));


        before = System.currentTimeMillis();
        for (int i = 0;  i < 10000000;  i++) {
            t.foo(t);
        }
        after = System.currentTimeMillis();
        System.out.println("with args: " + (after - before));

    }

    private int foo() {
        return hashCode() * 2;
    }

    private int foo(Object arg) {
        return arg.hashCode() * 2;
    }
}

我运行了几次，并没有发现foo()和foo(Object)通话效果之间存在任何显着差异。此外，有时arg-full版本比arg-less运行得更快：

c:\temp>java -cp . Test
no args: 17
with args: 20

c:\temp>java -cp . Test
no args: 17
with args: 18

c:\temp>java -cp . Test
no args: 16
with args: 19

c:\temp>java -cp . Test
no args: 17
with args: 18

在每个方法调用上传递引用或在实例创建时传递一次

4 个答案: