Java任务SetOnSuccedd不起作用

我有一个问题，与此类似，它不起作用。任务运行正常，但“setOnSucceeded”或“setOnFailed”从未运行过。我使用“执行器服务”。此外，该程序从未完成，它只是继续运行。我用“new Thread（task）.start（）；”尝试了它然后它成功构建，但是“setOnSucceeded”也不会触发

package stackoverflow;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import javafx.concurrent.Task;
import javafx.concurrent.WorkerStateEvent;
import javafx.event.EventHandler;

public class X {

    private ExecutorService exec;

    public X() {
        exec = Executors.newCachedThreadPool();
        run();
    }

    public static void main(String[] args) {
        X x = new X();
    }

    private void run() {
        Task<Void> task = new Task<Void>() {
            @Override
            public void run() {
                System.out.println("In Task");
                this.succeeded();
            }

            @Override
            protected Void call() throws Exception {
                throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
            }
        };

        task.setOnSucceeded((WorkerStateEvent event) -> {
            System.out.println("In set on Succeded");
        });

        task.setOnFailed((WorkerStateEvent event) -> {
            System.out.println("In Failed");
        });

        exec.execute(task);
    }

}

包堆栈溢出；
导入java.util.concurrent.ExecutorService；
导入java.util.concurrent.Executors；
导入javafx.concurrent.Task；
导入javafx.concurrent.WorkerStateEvent；
导入javafx.event.EventHandler；
公共X类{
私人遗嘱执行人；
公共X（）{
exec=Executors.newCachedThreadPool（）；
run（）；
}
公共静态void main（字符串[]args）{
X=新的X（）；
}
私家车{
任务=新任务（）{
@凌驾
公开募捐{
System.out.println（“任务中”）；
这个。成功了（）；
}
@凌驾
受保护的Void调用（）引发异常{
抛出新的UnsupportedOperationException（“尚未受支持”）；//若要更改生成的方法体，请选择“工具”“模板”。
}
};
task.setOnSucceeded（（WorkerStateEvent事件）->{
System.out.println（“成功设置时的输入”）；
});
task.setOnFailed（（WorkerStateEvent事件）->{
System.out.println（“输入失败”）；
});
执行（任务）；
}
}

JavaFX实用程序类的要点是JavaFX处理线程等所有问题。因此，您不需要创建任何

ExecutorService

或

Thread

或其他内容。另一方面，您需要启动一个

应用程序

，然后创建一个

服务

，该服务将创建一个

任务

另外，您不需要重写

run（）

，因为JavaFX已经实现了它。逻辑所在的方法是

call（）

。因此，在所有这些mambo jambo之后，JavaFX将为您创建

successed（）

方法。不要手动调用它，因为这只会引起混乱。另一方面，您可以覆盖它，这样就可以为

successed（）

hook提供另一个选项

下面是代码：

package stackoverflow;

import javafx.application.Application;
import javafx.concurrent.Service;
import javafx.concurrent.Task;
import javafx.concurrent.WorkerStateEvent;
import javafx.stage.Stage;

// extending Application
public class X extends Application {

    // Empty constructor. I just put it here so we know explicitly that a no-arg construcor exists.
    public X() {
        // NOP
    }

    @Override
    // a hook for starting the Applicatoin
    public void start(Stage primaryStage) {
        run();
    }

    // This is a proper entry point of a JavaFX application
    public static void main(String[] args) {
        launch(args);
    }

    private void run() {
        // creating a service, then running it
        ExampleService service = new ExampleService();
        service.start();
    }

    // this is the dummy service
    private static class ExampleService extends Service<Void> {

        @Override
        protected Task<Void> createTask() {
            Task<Void> task = new Task<Void>() {

                @Override
                protected Void call() throws Exception {
                    System.out.println("called");
                    // for Task<Void> we should return null
                    return null;
                }

                @Override
                protected void succeeded() {
                    // one hook - overriding
                    super.succeeded();
                    System.out.println("Succeded");
                }

                @Override
                protected void failed() {
                    // one hook - overriding
                    super.failed();
                    System.out.println("Failed");
                }
            };

            task.setOnSucceeded((WorkerStateEvent event) -> {
                // another hook - callback lambda
                System.out.println("In set on Succeded");
            });

            task.setOnFailed((WorkerStateEvent event) -> {
                // another hook - callback lambda
                System.out.println("In Failed");
            });
            return task;
        }

    }

}

start（）

是从

JavaFX应用程序线程通过某种
invokelaterddispatcher
调用的

call（）
方法是从
Thread-4
从
java.util.concurrent.ThreadPoolExecutor
调用的。JavaFX在异步任务方面似乎设计得非常好。在Swing中，我们必须维护线程池。在JavaFX中，我们不需要这样做，除非我们有JavaFX无法处理的特殊需求。我发现这是可能的，但不太可能。
此代码不适用compile@user6690200在ups中，我更改了它，因为我使用了executor服务，因为后来我动态创建了任务，我稍微修改了代码以显示更多的调试数据。显然，JavaFX已经使用了
ThreadPoolExecutor
。在答案中添加细节。
@Override
public void start(Stage primaryStage) {
    System.out.println("--> in start: " + Thread.currentThread().getName());
    Thread.dumpStack();
    run();
}


            @Override
            protected Void call() throws Exception {
                System.out.println("called in thread: " + Thread.currentThread().getName());
                Thread.dumpStack();
                return null;
            }