从线程进行Java方法调用

Question

如果我有一个游戏，每个客户端都有一个线程，维护有关该客户端的信息，而服务器有一个线程维护有关游戏世界的信息，则将从客户端线程之一调用主服务器线程上的方法来运行该线程，客户端线程还是服务器线程上的方法？

Answer 1

Threads are like the literal meaning of the word a string of commands. A computer has a single instruction pointer per thread to keep track where in the code the thread currently is. If you call a method, the program execution jumps there, and back once the method has finished. But it's not going to leave the thread. Code executing in a thread can never jump to a different thread.

The only way you can have your code execute in a different thread is to make the other thread call it for you.

But since you can't call the other thread directly, how can you make it call a method for you? Basically, program the other thread to wait for changes in a variable, and once it sees that variable change it can call the method.

So cross thread method invocation is actually communication through shared memory and it only works with special threads that are programmed to look at the shared memory. You can't execute code in Threads that just blindly do their thing.

To make it easy to program those things, we have BlockingQueue s in Java. Any thread can put things in and other threads can wait for something to come out. For example Runnable s that they execute.

    final BlockingQueue<Runnable> codeQueue = new LinkedBlockingQueue<>();
    Thread serverThread = new Thread(new Runnable() {
        @Override
        public void run() {
            while (!Thread.interrupted()) {
                try {
                    Runnable code = codeQueue.take();
                    // call code in my context.
                    code.run();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        }
    });
    Thread clientThread = new Thread(new Runnable() {
        @Override
        public void run() {
            codeQueue.add(new Runnable() {
                @Override
                public void run() {
                    System.out.println("Hello from Server Thread.");
                }
            });
        }
    });

In this example, clientThread causes serverThread to print "Hello from Server Thread." What serverThread does is also called an event loop. Because it waits for events and reacts to them.

Games typically have threads that do a (game) loop already. It's faily easy to add a line of code that checks for events and if it finds some to make it react to them. Anything bigger will already have a way to invoke code in different threads.

would calling a method on the main server thread from one of the client threads run that method on the client thread, or the server thread?

In the client thread.