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

Question

I'm making a simple game, and it has a single instance of a class named Game that deals with all the logic of the game.

Many of the classes in the project have a method called tick() which is called from within the Game instance 60 times per second and deals with updating information. Such instances are stored in list(s) in the Game class.

This method requires access to the Game class and currently looks like this:

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

My question is - would it be better to do as I am doing now and pass a reference hundreds and thousands of times per second to all the instances that require it or simply pass a single reference to these instances on creation and have the classes look like so:

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

Basically, how taxing it is to pass this reference so many times every second?

Thanks in advance.

Edit: Perhaps another option is to mark all the required members of the Game class as static and calling them as such without a reference at all?..

Answer 1

It's not that taxing. You should make the decision based on design, not speed.

Does the Game passed in ever change? If not, it's probably best to pass it in during the constructor, and make the field final for clarity.

But, are there many many Games? If so, it probably makes sense to pass it in the method so you don't have to construct tons and tons of MyClass - you can make due (perhaps) with only one.

Answer 2

Please profile before you find this to be a bottleneck. I don't think this really matters in your program.

But the cons are that the memory occupied by MyClass will increase if it has Game as a member. If you are creating a lot of MyClass your program will use more memory.

Answer 3

You'd probably have to profile this to get a definitive answer. You're balancing the cost of pushing an argument onto the stack and accessing the argument inside the function versus accessing an instance field from within the function. My guess is that this will be close to a wash.

If game changes identity during execution, then there's a big win for passing it as an argument every time. It doesn't sound like that applies in your case, however.

Answer 4

I was sure that there is no (or minimal) taxing but decided to verify this fact. Here is my code:

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;
    }
}

I ran it several times and did not see any significant difference between foo() and foo(Object) calls performance. Moreover sometimes arg-full version runs faster than 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