Ending console based multi threaded program gracefully

Question

I have the following class, I usually run about 10 threads of it

public class MyClass implements Runnable {    
  private volatile Device device = null;

  public MyClass(Device device) {
    this.device = device;
  }

  @Override
  public void run() {
    while (true) {  // <--- I do know that the "true" has to be changed to a Boolean
      try {
        Worker worker = new Worker();
        worker.work();
        System.out.println("Waiting 6 seconds!");
        Thread.sleep(6 * 1000);
        System.out.println("------------------------------------");
      } catch (Exception e) {
        e.printStackTrace();
      }
    }

    System.out.println("Thread in program ended!");
  }
}

and in my main I start the threads like this

for (int i = 0; i < 2; i++) {
  (new Thread(new MyClass())).start();
}

This is a console based program. What is the most reliable way to end the program? I think the best way would be to change while (true) to while (Boolean) and somehow change that Boolean for all threads, then when the loop ends, the program will end gracefully.

Answer 1

Here i'm ending it by waiting for a user input but you can change it to fire the stop method from anywhere

    public static void main(String[] args) {

    List<MyClass> myThreads = new ArrayList<>();
    for (int i = 0; i < 2; i++) {
        MyClass myClass = new MyClass();
        Thread t = new Thread(myClass);
        t.start();
        myThreads.add(myClass);
    }
    Scanner in = new Scanner(System.in);
    in.next();

    for(MyClass t : myThreads){
        t.stop();
    }

}

class MyClass implements Runnable {

private Boolean flag;

public MyClass() {
    this.flag = true;
}

@Override
public void run() {
    while (flag) {  // <--- I do know that the "true" has to be changed to a Boolean
        try {
            System.out.println("Waiting 6 seconds!");
            Thread.sleep(6 * 1000);
            System.out.println("------------------------------------");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    System.out.println("Thread in program ended!");
}

public void stop(){
    this.flag = false;
} }

Answer 2

The easy way would be to store all your threads in a set and make loop joining them at the end.
Be aware that this is not the most ortodox neither the most efficient way to do this.

In your main:

HashSet<Thread> threads = new HashSet();

for (int i = 0; i < 2; i++) {
    Thread t = new Thread(new MyClass());
    threads.add(t);
    t.start();
}

for (Thread thread: threads) {
    thread.join();
}

some more material

Answer 3

The following code uses an executor service to fix the number of threads that run at any time, it provides a Future object that also tells you when your thread has shutdown gracefully. They share a shutdown object as well. This offers you a bit more flexibility as the executor service can let you decide how many threads run at any one time gracefully.

First lets created a shared shutdown object that will notify all the threads it is time to shut down. There will be one instance of this and each thread will have a copy.

    public static class Shutdown {
        private boolean running;

        public void shutdown() {
            this.running = false;
        }

        public boolean isRunning() {
            return running;
        }
    }

Next let me just create a dummy thread that does nothing more than sleep forever while it is running. Obviously you can simply replace this with your own thread to do something useful.

    public static class MyClass implements Runnable {
        final Shutdown shutdown;


        public MyClass(Shutdown shutdown) {
            this.shutdown = shutdown;
        }

        @Override
        public void run() {
            while (shutdown.isRunning()) {
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    System.out.println("Did not gracefully shut down");
                }
            }

            System.out.println("Thread in program ended!");
        }
    }
}

Now for the main class which will run everything, this is where the magic happens.

public class Main {
    public static void main(String[] args) {

        //run exactly 10 threads at a time
        ExecutorService executorService = Executors.newFixedThreadPool(10);

        //this is how we shut it down
        Shutdown globalShutdown = new Shutdown();

        //start up the 10 threads
        List<Future<?>> futures = new ArrayList<>();
        for(int i = 0; i< 10; i++)
            futures.add(executorService.submit(new MyClass(globalShutdown)));

        //gracefully shut them down
        globalShutdown.shutdown();

        try {
            //wait for them all to shutdown
            for(Future<?> future : futures)
                future.get();
        } catch (InterruptedException e) {
            throw new IllegalStateException("This should never happen");
        } catch (ExecutionException e) {
            throw new IllegalStateException("This should never happen");
        }

        //everything got shutdown!
    }

in practice however you probably also want to handle the case where your thread may not end gracefully due to a bug. Rather than stall forever you might want to add a timeout and if that timeout is exceeded then simply forcibly terminate all remaining threads. To do that replace the above try-catch block with this.

    try {
        //wait for them all to shutdown
        boolean timedout = false;
        for(Future<?> future : futures) {
            if( !timedout ) {
                try {
                    future.get(30, TimeUnit.SECONDS);
                } catch (TimeoutException e) {
                    timedout = true;
                }
            }

            if(timedout) {
                future.cancel(true);
            }
        }
    } catch (InterruptedException | ExecutionException e) {
        throw new IllegalStateException("This should never happen");
    }