Is stopping the runnable object equivalent to stopping the thread?

Question

Given this code:

public class Game implements Runnable {
  private volatile boolean stop;

  public Game() {
    ...
  }

  public void run() {
    while(!stop) {
      // play game
    }
  }

  public void stopGame() {
    stop = true;
  }
}

public class Main {

  public static void main(String[] args){
    Game g = new Game(); // Game class implements Runnable
    Thread t = new Thread(g);
    t.start();
    // do the two method calls below effectively do the same thing?
    t.interrupt();
    g.stopGame(); 
  }

}

Does stopGame() kill the thread as effectively as using something like interrupt, or a java.lang.Thread method to kill the thread? (I'm not too familiar with how you would kill a thread using a Thread method.)

Also, in the case that stopGame() is the best way to kill a thread, is there any to call it if they only had access to the Thread instance like below:

public static void Main(String[] args){
  List<Thread> threads = new ArrayList<Thread>();
  threads.add(new Thread(new Game()));
  // can you access the Game instance given the Thread instance 
  // or do you need to hold onto the reference of the Game instance?
  threads.get(0).stopGame(); // for example, this won't work.
}

Answer 1

Does stopGame() stop the thread as effectively as using something like interrupt, or a java.lang.Thread method to kill the thread? (I'm not too familiar with how you would kill a thread using a Thread method.)

The best way to stop a thread is to return from the run() method.

Your stopGame() call causes this on the next pass through the loop. But if that loop includes blocking calls, that next pass may occur after a delay -- or never.

Methods to kill the thread are deprecated because they're inherently unsafe.

Thread.interrupt() is not guaranteed to stop an arbitrary thread. It wakes up some blocking calls. It is common -- but not universal -- for a Runnable to stop when catching an InterruptedException. From the Java tutorial on interrupts:

An interrupt is an indication to a thread that it should stop what it is doing and do something else. It's up to the programmer to decide exactly how a thread responds to an interrupt, but it is very common for the thread to terminate.

One approach is to both set a user-defined flag and call Thread.interrupt(). That will interrupt any blocking calls, and work even if code called by the Runnable has caught the InterruptedException or cleared the interrupt status flag.

Also, in the case that stopGame() is the best way to kill a thread, is there any to call it if they only had access to the Thread instance like below:

You could subclass Thread to hold a Game and provide a method in your subclass to stop the game. However, it's usually easier just to track the Runnable instances separately.

Answer 2

"Killing" a thread is an abnormal situation.

The interrupt() method may do the job but in this case you don't need to use a boolean flag in the while condition of the run() method.
This :

  public void run() {
    while(!stop) {
      // play game
    }
  }

could be :

  public void run() {            
      while (!Thread.currentThread().isInterrupted()) {
         // play game
      }                
  }

But personally, I find it an aggressive way to stop the thread as any blocking call of the interrupted thread will be woken up.
You may so be forced to handle this premature exit that may create inconsistency while you are in a normal exit case.
Using a boolean flag lets the thread code be responsible of doing the job as it deems that it should be without forcing the exist of its blocking calls.

It doesn't mean that the InterruptedException should never be handled but I think that for a normal case (exit from user request), it makes no sense to make the code more complex as it is required.

Does stopGame() kill the thread as effectively as using something like interrupt, or a java.lang.Thread method to kill the thread?

The suitable way to end a thread is allowing it to terminate its execution : that is the run() of the method finishes its execution.

Using a boolean condition with a while as you are doing here is fine :

public void run() {
    while(!stop) {
      // play game
    }
  }

Also, in the case that stopGame() is the best way to kill a thread, is there any to call it if they only had access to the Thread instance like below:

You could do it for example :

  Game game = new Game(); 
  game.start();
  ...
  game.stopGame();