How do I safely stop multiple threads?

Question

I have created a little example(below) on my attempt to safely stop multiple threads when a user clicks on a Stop button on the user interface. However it seems like after this attempt, the threads still seems to be running. Can you please point me in the right direction?

Edit

Thanks for the comments everyone, just to go along with the post, I have modified the code below with the volatile boolean flag, and it seems to be working fine until I do some I/O operations.
If I add I/O operations, the threads seems to be running even if call fstream.close and then call the stop function to turn the boolean flag on... (Profiled the program to double-check that the threads were still running). Is there any other thing I need to do in order to take care of the opened files, and eventually stop the threads?
Thanks again.

Fixed and working code.

class MultiThreadExample implements Runnable {
    private static final MultiThreadExample threadObj = new MultiThreadExample();
    ArrayList<Thread> threadList = new ArrayList<Thread>();

    public static MultiThreadExample getInstance() {
      return threadObj;
    }

    public void tester() {
      File file = new File("data/");
      File[] files = file.listFiles();
      for (int i = 0; i < files.length; i++) {
        Thread thread = new Thread(new ThreadedCrawler(), files[i].toString());
        thread.start();
        threadList.add(thread);
      }
    }

    public void run() {
      try {
        ProgramTester.getInstance().doSomething();          
      }
      finally { 
        do other stuff 
      }
    }


    public synchronized void stop() throws IOException {
      for (Thread threads : threadList) 
         threads.interrupt();
    }

    public void doSomething() {
      FileInputStream fstream = new FileInputStream(file);
      BufferedReader br = new BufferedReader(new InputStreamReader(fstream));
      String inLine;
      while (((inLine = br.readLine()) != null) &&  !Thread.currentThread().isInterrupted()) {
        do something...
           for()...
               ....
               }
    }
}

public class GuiExample extends JFrame {
    ....
    public void mousePressed(MouseEvent e) {
      try {
        MultiThreadExample.getInstance().stop();
      }
      catch (InterruptedException e1) {
        e1.printStackTrace();
      }
    }
}

Small hint: I would give the "worker threads" a slightly lower priority than the management thread (in this case the threads performing the GUI event handling, probably set to default or higher prio). Otherwise, if you create (too) many threads, you may have a hard time killing them. That said, if you are performing file actions, your threads will probably spend most of the time waiting for the kernel to return, making the above point moot. — Maarten Bodewes, Feb 01 '12 at 23:52

score 4 · Accepted Answer · edited May 23 '17 at 12:30

4

interrupt() doesn't stop the thread (see the API). The preferred way of handling this is for your run() method to periodically check a flag and exit when it's set (of course you set the flag when you want terminate the thread).

stop() kills the thread, but it's been deprecated for a long time (with good reason).

same question here

Update

Since you check the flag outside of doSomething(), it won't exit until the method completes, so long running tasks (like file io) will continue.

Move the check to the loop over br.readLine(), as others have suggested, using interrupt() / isInterrupted() is probably better here, since it will also stop threads blocked on io.

edited May 23 '17 at 12:30

Community

1
1

answered Feb 01 '12 at 23:42

Dmitri

8,999
5
36
43

+1. Adding to this, you could use a simple `boolean` as a flag in this case but make sure you declare it as `volatile` to ensure thread-safety. – Dawood Feb 01 '12 at 23:55
I have done the flag approach before, and thanks for pointing that out.l I was just wondering if there was another way like I was doing in the above code. – xDG Feb 01 '12 at 23:56
Thanks for the help @Dmitri, that was obvious. I will edit the code in case others whats to see it. -xD – xDG Feb 03 '12 at 20:11

score 1 · Answer 2 · answered Feb 01 '12 at 23:51

interrupt() will stop the thread, iff they periodically check isInterrupted() or interrupted(). Which is now common practice - preferable, IMO, to periodically checking a flag as suggested by @Dmitri.

But, for this to work, you need to make sure that your threads/Runnables periodically check their interrupt status.

score 0 · Answer 3 · answered Feb 01 '12 at 23:53

Stopping threads in Java is a cooperative process.

First there must be a mechanism to signal the desire for the thread to stop (called by another thread). Thread.interrupt is a built-in method of doing this.

Secondly the target thread must cooperate and obey the 'stop' signal whatever that may be.

One method is for a thread to call interrupt on the target thread. The target thread should periodically call Thread.interrupted and if it returns true terminate gracefully.

Another approach is to use a volatile boolean flag which a thread sets to true to terminate and the target thread checks the flag periodically. To be honest this approach is pretty much a hand-rolled interruption system.

How do I safely stop multiple threads?

3 Answers3

Update