Safe way to stop Java thread

Question

Can anyone explain to me why the first thread doesn't work and the second works perfectly:

public class Test {

    public static void main(String args[]) throws InterruptedException {
        TestThread1 t1 = new TestThread1();
        TestThread2 t2 = new TestThread2();

        t1.startThread();
        t2.start();

        Thread.sleep(4000);

        t1.stopThread();
        t2.stopThread();
    }
}

class TestThread1 extends Thread {

    private volatile TestThread1 thread;

    public void startThread() {
        thread = new TestThread1();
        thread.start();
    }

    public void run() {
        while (thread != null) {
            System.out.println("RUNNING 1 ...");
        }
    }

    public void stopThread() {
        thread = null;
    }
}

class TestThread2 extends Thread {

    private volatile boolean finished = false;

    public void run() {
        while (!finished) {
            System.out.println("RUNNING 2 ...");
        }
    }

    public void stopThread() {
        finished = true;
    }
}

When I debug inside TestThread1 class: Inside startThread, the thread member is filled (so it is not null), inside run, thread member is null!!! And finally, inside stopThread, the thread member is not null!!!

Can anyone explain to me what is happening here?

Answer 1

Here, you have two instances of TestThread1 t1:

• One is stored into your t1 local variable (in your main method).
• One is stored into your thread instance variable (of t1).

t1 is never started, t1.thread is.

t1.stopThread() sets t1.thread to null, but it doesn't affect t1.thread.thread.

Since you're starting t1.thread, its run method is using t1.thread.thread:

• This is never set to anything (so it's using null).
• Calling t1.stopThread() like you do would only set t1.thread to null, which wouldn't affect t1.thread.thread.

---

More generally, you can't just "kill" a thread as such, but you can implement tests within the method to tell it to return under certain circumstances. What you've done with your second test is closer to this (using while (!finished) { ... } with a volatile variable).

I wouldn't limit the test to finished. It's also useful to test whether the thread was interrupted, in particular because if you run your runnables within an ExecutorService shutdownNow() will try to interrupt them (see this question).

I'd use while (!finished && !Thread.currentThread().isInterrupted()) { ... }.

(Note the difference between Thread.currentThread().isInterrupted() and Thread.interrupted(): they may seem similar, but the latter will also reset the status, which you might not want.)

Depending on what's within your loop (or whether there is a loop at all), you may want to use something like if (finished || Thread.currentThread().isInterrupted()) { return; } at various strategic points, where it makes sense.

Answer 2

TestThread1 t1 = new TestThread1();
t1.startThread();

This will simply call method startThread() on object t1. Inside this method you are creating a new Thread.

thread = new TestThread1();
        thread.start();

But for this Thread thread instance variable is null(It is not null for t1).

So in both cases thread variable should be null.

Answer 3

There is two TestThread1 object being created, one is started and the other is stopped.

I suggest not extending Thread and instead wrapping your Runnable once.

Answer 4

Because in your main method you create a Thread1 Object. You then run startThread which creates a different Thread1 object inside the first one and sets it to the field thread. You then start the second object which didn't have its own thread field initialized. When run method is run on the second object the condition is false and the while loop doesn't start.

Your object hierarchy looks something like this

t1 (Thread1) {
    thread(Thread1): {
        thread: null;
        run() {
             while (thread != null) {...} // this is the method that is run - thread is null here since you never initialized it
        }
   };
   startThread() {} // calls the run method on the nested thread object above
   run() {
        while (thread != null) {...} // this method is not run since t1.start() is never called in main()
   }
}

Answer 5

in your case,

 t2.start();

is calling run method directly, it is not creating thread inside startThread method.

so t1.stopThread() makes the volatile thread inside Thread1 class null. so you are getting like that.

solution

use

 t1.startThread();
        t2.startThread();

instead of

 t1.startThread();
        t2.start();

which makes 2 threads to create separate threads inside that method.

if you want a single thread of Thread1 then use runnable interface and create 2 threads and call startThread respectively rather than creating extra threads inside main.