Java - Stop thread from a different class

Question

I'm trying to stop a java thread from a different class, but unable to figure out. I have looked into the below links, googled a lot from past 2 days but unable to nail down. May be a simple thing which i need to change but i'm out of options and hence posting it here.

Referred Links

• java external threads (outside the class file it's used)
• http://tutorials.jenkov.com/java-concurrency/creating-and-starting-threads.html
• http://www.java2novice.com/java_thread_examples/

While typing the question, I referred the below links as well..
Stop a thread from outside

Below is my code sample. I'm able to start the WorkerThread from the MainThread and get into the loop. But unable to stop the thread started using the StopThread class.

I've also used the volatile option suggested in the below link.
http://tutorials.jenkov.com/java-concurrency/volatile.html

I feel I'm making a simple mistake, but not able to identify it.

//class WorkerThread
package main;
public class WorkerThread implements Runnable
{
    public WorkerThread() {
        isRunning = true;
    }
    public WorkerThread(boolean False) {
        isRunning = False;
    }
    private volatile boolean isRunning;
    public synchronized void stopThread() {
        isRunning = false;
    }
    public synchronized boolean IsThreadRunning() {
        return isRunning;
    }
    @Override
    public void run() 
    {
        int i = 1;
        while(isRunning)
        {
            System.out.println("Loop " + i);
            i++;
            try { Thread.sleep(2000); } 
            catch (InterruptedException e) { e.printStackTrace(); }
        }
    }
}

//class MainThread
package main;
public class MainThread 
{
    public static Thread t;

    public static void main(String[] args) 
    {
        t = new Thread(new WorkerThread());
        t.start();
    }
}

//class StopThread
package main;
public class StopThread 
{
    public static void main(String[] args) 
    {
        //What should i write here to stop the thread started by MainThread
        MainThread.t.interrupt();
    }
}

Answer 1

public class MainThread 
{
    public static Thread t;

    public static void main(String[] args) 
    {
        t = new Thread(new WorkerThread());
        t.start();
    }
}


public class StopThread 
{
    public static void main(String[] args) 
    {
        MainThread.t.interrupt();
    }
}

It is not safe to call Thread.stop() it is listed as deprecated in JavaDocs

Also this may be just for the sake of this question, but why does your program have two main methods?

Answer 2

Make thread t a public member of class MainThread, and then just call MainThread.t.interrupt() from StopThread

Answer 3

You have an opportunity to make use of what you defined volatile variable and gracefully come out of thread like below:

public class MainThread 
{
    public static WorkerThread workerThread;

    public static void main(String[] args) 
    {
        workerThread = new WorkerThread();
        Thread t = new Thread(workerThread);
        t.start();
    }
}

public class StopThread 
{
    public static void main(String[] args) 
    {
        Main.workerThread.stopThread();
    }
}

Answer 4

Note: This solution works but not a perfect solution.

You can write and read value of isRunning variable from a properties file. This way you can have interaction between two different java processes. ThreadWorker just creates file upon initiation & and just makes attempt to read the file after that. StopThread modifies the properties file when triggered which should be picked up by ThreadWorker.

Check below example:

public class ThreadWorker implements Runnable
{
    public volatile static boolean isRunning = false;

    public ThreadWorker() {
        Properties p = new Properties();
        p.setProperty("isRunning", "1");
        FileOutputStream out;
        try {
          //Writes all properties in appProperties file
            out = new FileOutputStream("appProperties");
            p.store(out, "---Thread Status----");
            out.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    @Override
    public void run() 
    {
        int i = 1;
        String status = "1";
        while("1".equals(status))
        {
            status = getStatus();
            System.out.println("Loop " + i);
            i++;
            try { Thread.sleep(2000); } 
            catch (InterruptedException e) { e.printStackTrace(); }
        }
    }

    public String getStatus() {
        FileInputStream in;
        Properties p = new Properties();
        try {
            in = new FileInputStream("appProperties");
            p.load(in);
            return p.getProperty("isRunning");
            in.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();

        } 

    }
}


//class StopThread
public class StopThread 
{
    public static void main(String[] args) 
    {
        Properties p = new Properties();
        p.setProperty("isRunning", "0");
        FileOutputStream out;
        try {
            out = new FileOutputStream("appProperties");
            p.store(out, "---Thread Status----");
            out.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

//class StopThread
public class StopThread 
{
    public static void main(String[] args) 
    {
        Properties p = new Properties();
        p.setProperty("isRunning", "0");
        FileOutputStream out;
        try {
            out = new FileOutputStream("appProperties");
            p.store(out, "---Thread Status----");
            out.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}