使用ExecutorService时的奇怪线程行为

Question

Below is my code:

public class Controller {
    public Button button_submitWork;

    @FXML
    public void handleSubmitWork(ActionEvent event) {
        final ExecutorService executorService = Executors.newFixedThreadPool(1, r -> {
            Thread t = Executors.defaultThreadFactory().newThread(r);
            t.setDaemon(true);
            return t;
        });//set thread daemon, let all threads terminate when the program is closed.
        Callable<String> callable = new Callable<String>() {
            @Override
            public String call() throws Exception {
                System.out.println("Executor Service thread");
                StringBuilder stringBuilder_output = new StringBuilder();
                for (int k = 0; k < 5; k++) {
                    stringBuilder_output.append(k);
                }
                //Thread.sleep(1000);
                return stringBuilder_output.toString() + "\n";
            }
        };
        Future<String> future = executorService.submit(callable);//Weird line. 
        //This line must be placed inside the "watchThread" to get the result, but why???
        Thread watchThread = new Thread(new Runnable() {
            @Override
            public void run() {
                //<----------Moving to here solve the problem!
                System.out.println("Watch thread");
                while (!Thread.currentThread().isInterrupted() && !future.isDone()) {
                    try {
                        String result = future.get();
                        System.out.println(result);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (ExecutionException e) {
                        e.printStackTrace();
                    } finally {
                        executorService.shutdownNow();
                    }
                }
            }
        });
        watchThread.setDaemon(true);
        watchThread.start();
        System.out.println("FX thread");
    }
}

The question is that the System.out.println(result); inside "watchThread" is never been called. The console output looks like this:

Executor Service thread
FX thread
Watch thread

But when I move the Future<String> future = executorService.submit(callable); to the inside of run method of "watchThread", the output change to:

FX thread
Watch thread
Executor Service thread
01234

which is I expected. I also discovered that if the call() method has a longer task, say a Thread.sleep(1000) , the output change to the result I expected.

So why is that?

Answer 1

The thread you submit to executorService finishes before this line:
while (!Thread.currentThread().isInterrupted() && !future.isDone()) { is called so future.isDone returns true and the while loop is not executed.

If you add Thread.sleep(1000) then it still runs and future.isDone returns false and the while loop executes. The same thing happens when you move Future<String> future = executorService.submit(callable); inside watchThread .