abstract class BackgroundTask<V> implements Runnable, Future<V> {
        private final FutureTask<V> computation = new Computation();
        private class Computation extends FutureTask<V> {
            public Computation() {
                super(new Callable<V>() {
                    public V call() throws Exception {
                        return BackgroundTask.this.compute() ;
                    }
                });
            }
            protected final void done() {
                GuiExecutor.instance().execute(new Runnable() {
                    public void run() {
                        V value = null;
                        Throwable thrown = null;
                        boolean cancelled = false;
                        try {
                            value = get();
                        } catch (ExecutionException e) {
                            thrown = e.getCause();
                        } catch (CancellationException e) {
                            cancelled = true;
                        } catch (InterruptedException consumed) {
                        } finally {
                            onCompletion(value, thrown, cancelled);
                        }
                    };
                });
            }
        }
        protected void setProgress(final int current, final int max) {
            GuiExecutor.instance().execute(new Runnable() {
                public void run() { onProgress(current, max); }
            });
        }
        // Called in the background thread так как задача длинная и мы хотим, чтобы приложение не подвисало.
        protected abstract V compute() throws Exception;
        // Called in the event thread - почему?
        protected void onCompletion(V result, Throwable exception,
                                    boolean cancelled) { }
        protected void onProgress(int current, int max) { }
        // Other Future methods forwarded to computation
        //вызываем этот метод, если хотим сделать cancel задаче. Вызывается в event thread насколько я понимаю
        public boolean cancel(boolean mayInterruptIfRunning) { 
             return computation.cancel(mayInterruptIfRunning);
        }
        public void run() {// просто делегируем объекту computation 
             computation.run();
        }
    }

       FutureTask futureTask = new FutureTask(new Callable() {
            @Override
            public Object call() throws Exception {
                System.out.println(Thread.currentThread().getId() + " works");

                return null;
            }

        }) {
            @Override
            protected void done() {
                System.out.println(Thread.currentThread().getId() + " done");
            }
        };

        ExecutorService executorService = Executors.newFixedThreadPool(1);
        executorService.execute(futureTask);
        executorService.shutdown();

11 works
11 done

 private void runInBackground(final Runnable task) {
        startButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                class CancelListener implements ActionListener {
                    BackgroundTask<?> task;
                    public void actionPerformed(ActionEvent event) {
                        if (task != null)
                            task.cancel(true);
                    }
                }
                final CancelListener listener = new CancelListener();
                listener.task = new BackgroundTask<Void>() {
                    public Void compute() {
                        while (moreWork() && !isCancelled())
                            doSomeWork();
                        return null;
                    }

                    private boolean moreWork() {
                        return false;
                    }

                    private void doSomeWork() {
                    }

                    public void onCompletion(boolean cancelled, String s, Throwable exception) {
                        cancelButton.removeActionListener(listener);
                        label.setText("done");
                    }
                };
                cancelButton.addActionListener(listener);
                exec.execute(task);
            }
        });
    }