'；计划服务'；在Javafx中

我是一名学生，从一个月开始学习JavaFX。 我正在开发一个应用程序，希望服务在执行任务后重新启动。为此，我知道使用了“”。 因此，任何人都可以用一个简单的例子来解释scheduledservice的使用，以及它与JavaFX中的“服务”有何不同。谢谢；）

编辑：如何定义此名为DataThread的ScheduledService应每5秒重新启动一次

public class DataThread extends ScheduledService<Void>
{
    @Override
    public Task<Void> createTask() {
        return new Task<Void>() {
            @Override
            public Void call() throws Exception {
             for(i=0;i<10;i++)
             {
                 System.out.println(""+i);
             }
              return null;
            }
        };
    }
}  

公共类DataThread扩展ScheduledService
{
@凌驾
公共任务createTask（）{
返回新任务（）{
@凌驾
public Void call（）引发异常{
对于（i=0；i，考虑到您对类有很好的了解。它只是一个具有调度功能的服务

来自文档

ScheduledService是一种在成功执行后自动重新启动自身的服务，在某些情况下，即使出现故障也会重新启动

所以我们可以这样说

Service -> Execute One Task
ScheduledService -> Execute Same Task at regular intervals

定时服务的一个非常简单的例子是TimerService，它统计服务任务被调用的次数，并计划每1秒调用一次

import java.util.concurrent.atomic.AtomicInteger;

import javafx.application.Application;
import javafx.beans.property.IntegerProperty;
import javafx.beans.property.SimpleIntegerProperty;
import javafx.concurrent.ScheduledService;
import javafx.concurrent.Task;
import javafx.concurrent.WorkerStateEvent;
import javafx.event.EventHandler;
import javafx.stage.Stage;
import javafx.util.Duration;

public class TimerServiceApp extends Application {

    @Override
    public void start(Stage stage) throws Exception {
        TimerService service = new TimerService();
        AtomicInteger count = new AtomicInteger(0);
        service.setCount(count.get());
        service.setPeriod(Duration.seconds(1));
        service.setOnSucceeded(new EventHandler<WorkerStateEvent>() {

            @Override
            public void handle(WorkerStateEvent t) {
                System.out.println("Called : " + t.getSource().getValue()
                        + " time(s)");
                count.set((int) t.getSource().getValue());
            }
        });
        service.start();
    }

    public static void main(String[] args) {
        launch();
    }

    private static class TimerService extends ScheduledService<Integer> {
        private IntegerProperty count = new SimpleIntegerProperty();

        public final void setCount(Integer value) {
            count.set(value);
        }

        public final Integer getCount() {
            return count.get();
        }

        public final IntegerProperty countProperty() {
            return count;
        }

        protected Task<Integer> createTask() {
            return new Task<Integer>() {
                protected Integer call() {
                    //Adds 1 to the count
                    count.set(getCount() + 1);
                    return getCount();
                }
            };
        }
    }
}

导入java.util.concurrent.AtomicInteger；
导入javafx.application.application；
导入javafx.beans.property.IntegerProperty；
导入javafx.beans.property.SimpleIntegerProperty；
导入javafx.concurrent.ScheduledService；
导入javafx.concurrent.Task；
导入javafx.concurrent.WorkerStateEvent；
导入javafx.event.EventHandler；
导入javafx.stage.stage；
导入javafx.util.Duration；
公共类TimerServiceApp扩展应用程序{
@凌驾
public void start（Stage）引发异常{
TimerService服务=新的TimerService（）；
AtomicInteger计数=新的AtomicInteger（0）；
setCount（count.get（））；
服务设置周期（持续时间秒（1））；
setOnSucceeded（新的EventHandler（）{
@凌驾
公共无效句柄（WorkerStateT事件）{
System.out.println（“调用：”+t.getSource（）.getValue（））
+"时间";；
set（（int）t.getSource（）.getValue（））；
}
});
service.start（）；
}
公共静态void main（字符串[]args）{
发射（）；
}
私有静态类TimerService扩展ScheduledService{
私有IntegerProperty计数=新的SimpleIntegerProperty（）；
公共最终无效集合计数（整数值）{
计数。设置（值）；
}
公共最终整数getCount（）{
返回count.get（）；
}
公共最终整数属性countProperty（）{
返回计数；
}
受保护的任务createTask（）{
返回新任务（）{
受保护的整数调用（）{
//将计数加1
count.set（getCount（）+1）；
返回getCount（）；
}
};
}
}
}
谢谢。这正是我想要的。只需设置
service.setPeriod（Duration.seconds（5））；