javafx get result from thread with callable

Question

I have a javafx app, and I want to surround some code with "waiting" feature. So my code can be Runnable and Callable. The problem is getting result from Callabe. I tried to play with:

• wait()/notify()
• Platform.runLater
• creating daemon threads by hands
• Service

after reading some articles here, but it doesn't help.

How I want to call it:

            final String a =
                    CommonHelper.showWaiting(() -> {
                             System.out.println("test");
                             return "test2";  
                    });

That's how I work with Runnable:

public static void showWaiting(Runnable runnable) {
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        try {
            executorService.submit(new WaitingTask<>(executorService.submit(runnable)));
        } finally {
            executorService.shutdown();
        }
    }

And my WaitingTask is:

public class WaitingTask<T> extends Task<Void> {
    @Getter
    private final Future<T> future;

    public WaitingTask(Future<T> future) {
        this.future = future;
    }

    @Override
    protected Void call() {
            showSpinner();
            while (true) {
                if (future.isDone()) {
                    hideSpinner();
                    break;
                }
            }
        }
        return null;
    }
}

That works awesome - my app shows waiting spinner, and task runns in separate thread.

So I try to work the same way with Callable to get the result:

public static <T> T showWaiting(Callable<T> callable) {
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        try {
            FutureTask<T> task = new FutureTask<>(callable);
            Future<T> result = (Future<T>) executorService.submit(task);
            executorService.submit(new WaitingTask<>(result));
            return result.get();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            executorService.shutdown();
        }
    }

but I can not see waiting spinner, maybe the app's main thread waits for result.get(); and the app freezes. How can I fix it?

Answer 1

There are a few things you are doing incorrectly:

---

1. You wrap your Callable in a FutureTask before submitting it to an ExecutorService. You don't need to do this, and in fact you shouldn't do this. Instead, just submit your Callable directly and you will get a Future in return.

   Future<T> future = executor.submit(callable);
   

   If you're using the core implementation of ExecutorService the returned Future will be a FutureTask anyway. Not that you should care—the only important thing is that its a Future. Note the same goes for Runnables; just submit them directly, don't wrap them in a FutureTask first.

---

2. You're submitting your Callable, getting a Future, and wrapping said Future in a Task...and then submitting your Task. This means you will have two tasks for every one you want to execute. Depending on how your ExecutorService is configured, this equates to using two threads per task.

   You should be using your Task as if it was your Callable. Do the work inside the Task#call() method and return the result. Then only submit the Task, don't wrap it in anything first.

   executor.execute(task); // Don't need the Future here, just use "execute"
   

   If you want the result of the Task you can register callbacks (see this). The class is designed to invoke these callbacks on the JavaFX Application Thread.

   task.setOnSucceeded(event -> {
       T value = task.getValue();
       // do something with value...
   });
   

   Note that Task extends FutureTask. This seems contradictory to point 1, but that's just how it is. Personally, I wouldn't have designed the class that way—it ends up wrapping the Task in another Future (likely FutureTask) when executed using the Executor Framework.

---

3. This is related to number 2; if you fix that issue then this issue inherently goes away.

   You are spin waiting for the wrapped Future to complete. This is a waste of resources. The Future interface has a get() method that will block the calling thread until said Future is done. If the Future completes normally you'll get the value in return, else if it completes exceptionally an ExecutionException will be thrown. The third option is the calling thread is interrupted and an InterruptedException is thrown.

---

4. If the method names "showSpinner" and "hideSpinner" aren't misleading, you are updating the UI from a background thread. Never update the UI from a thread other than the JavaFX Application Thread. Now, you could wrap those calls in a Platform.runLater action, but you could also use the properties/callbacks of the Task. For instance, you could listen to the running property to know when to show and hide your spinner.

---

Taking all that into account, your example should look more like:

// Doesn't have to be an anonymous class
Task<String> task = new Task<>() {

    @Override 
    protected String call() {
        System.out.println("test");
        return "test2";
    }

});
task.runningProperty().addListener((obs, wasRunning, isRunning) -> {
    if (isRunning) {
        showSpinner();
    } else {
        hideSpinner();
    }
});
task.setOnSucceeded(event -> {
    String a = task.getValue();
    // Do something with value.
});

executorService.execute(task);

For more information, I suggest reading:

• Concurrency in JavaFX
• Documentation of javafx.concurrent.Worker
• Documentation of javafx.concurrent.Task (and Worker's other implementations)
• Possibly a tutorial on Java's Executor Framework.

Answer 2

Thanks all for help, especially @Slaw and @kendavidson Finally I've found a simple and perfect solution here: Modal JaxaFX Progress Indicator running in Background

Maybe I'll post my full generic-based example here, based on this principles