Module  javafx.graphics
软件包  javafx.concurrent

Class Task<V>

  • All Implemented Interfaces:
    Runnable ， Future<V> ， RunnableFuture<V> ， Worker<V> ， EventTarget 

    public abstract class Task<V>
extends FutureTask<V>
implements Worker<V>, EventTarget

    一个完全可观察到的一个FutureTask的实现。 Task暴露了额外的状态和可观察属性，可用于在JavaFX中编程异步任务，如Worker界面中所定义。 任务的实现必须覆盖call()方法。 这个方法在后台线程上被调用。 在此方法中使用的任何状态必须能够安全地从后台线程读写。 例如，从此方法处理实时场景图是不安全的，并将导致运行时异常。

    任务灵活，对于“工作”的封装非常有用。 因为Service被设计为执行任务，所以应用程序或库代码定义的任何任务都可以轻松地与服务一起使用。 同样，由于Task从FutureTask扩展，使用Java并发Executor API的Task是非常简单和自然的。 由于任务是可运行的，您还可以从另一个后台线程直接调用（通过调用FutureTask.run()方法）。 这允许组合工作，或将其传递给手动构造和执行的新线程。 最后，由于您可以手动创建一个新的线程，传递一个Runnable，可以使用以下成语： 

       Thread th = new Thread(task); th.setDaemon(true); th.start();

    请注意，此代码将线程的守护程序标志设置为true。 如果你想要一个后台线程来防止在最后一个阶段关闭之后退出VM，那么你希望守护进程是假的。 但是，如果您希望后台线程在所有阶段关闭后立即终止，那么您必须将守护程序设置为true。

    虽然ExecutorService定义了几个方法，这需要一个Runnable，你通常应该限制自己使用execute从继承的方法Executor 。

    与FutureTask一样，任务是一个单一的类，不能重复使用。 见Service的可重复使用的Worker 。

    由于该任务旨在与JavaFX GUI应用程序一起使用，因此可确保对其公共属性进行的每次更改以及更改状态，错误和事件处理程序的通知都会发生在主要的JavaFX应用程序线程上。 从后台线程（包括call()方法）访问这些属性将导致运行时异常被引发。 唯一的例外是初始配置任务时，可以从任何线程安全地完成。 但是，一旦Task已被初始化和启动，它可能只能在FX线程之外被使用（除了清楚地标记为适合子类从后台线程调用的那些方法之外）。

    强烈建议所有的Tasks都将用Task进行操作的不可变状态进行初始化。 这应该通过提供一个Task构造函数来完成，该构造函数需要执行Task所需的参数。 不变状态使得使用任何线程变得容易和安全，并确保在多个线程的存在下的正确性。

    在Java中没有可靠的方法来“杀死”一个进程中的线程。 但是，当对任务调用cancel时，重要的是任务停止处理。 “任务”任务即使在任务被取消之后也可能继续处理和更新消息，文本和进度属性！ 在Java中，取消任务是一个合作的努力。 任务的用户将要求其被取消，并且任务的作者必须检查是否已经在call方法的主体内被取消。 有两种方法可以完成。 首先，Task作者可以检查isCancelled方法，继承自FutureTask ，看看Task是否被取消。 第二，如果Task实现使用任何阻塞调用（例如NIO InterruptibleChannels或Thread.sleep），并且在这种阻塞调用中任务被取消，则抛出InterruptedException。 具有阻塞调用的任务实现应该认识到，被中断的线程可能是被取消任务的信号，并且应该仔细检查isCancelled方法，以确保由于取消任务而导致InterruptedException异常。

    例子

    以下一组示例演示了Tasks最常用的一些用途。

    一个简单的循环

    第一个例子是一个简单的循环，没有什么特别有用的，但是演示了正确编写任务的基本方面。 该示例将简单地循环并打印到每个循环迭代的标准输出。 当它完成时，它返回它重复的次数。 

       Task<Integer> task = new Task<Integer>() { @Override protected Integer call() throws Exception { int iterations; for (iterations = 0; iterations < 100000; iterations++) { if (isCancelled()) { break; } System.out.println("Iteration " + iterations); } return iterations; } };

    首先，我们定义从此任务返回的值的类型。 在这种情况下，我们要返回我们迭代的次数，所以我们将使用泛型指定Task类型为Integer。 然后，在call方法的实现中，我们从0到100000迭代。在每次迭代中，我们检查这个任务是否被取消。 如果已经存在，那么我们就会跳出循环并返回我们迭代的次数。 否则，会将消息打印到控制台，并且迭代计数增加，我们继续循环。

    检查循环体中的isCancelled（）是至关重要的，否则开发者可能会取消任务，但任务将继续运行并更新进度，并从call方法结束返回错误的结果。 任务的正确实施将始终检查取消。

    具有进度通知的简单循环

    与前面的例子相似，除了这一次我们将在每次迭代中修改Task的进度。 请注意，我们可以选择取消订单。 当任务被取消时，是否要将进度设置为-1（不确定），还是要将进度保留在哪里？ 在这种情况下，让我们单独离开进度，只有在取消消息时更新消息，尽管在取消之后更新进度是完全有效的选择。 

       Task<Integer> task = new Task<Integer>() { @Override protected Integer call() throws Exception { int iterations; for (iterations = 0; iterations < 10000000; iterations++) { if (isCancelled()) { updateMessage("Cancelled"); break; } updateMessage("Iteration " + iterations); updateProgress(iterations, 10000000); } return iterations; } };

    像以前一样，在for循环中，我们检查Task是否被取消。 如果已被取消，我们将更新该任务的消息，表示已被取消，然后如前所述那样断开。 如果任务尚未被取消，那么我们将更新其消息以指示当前的迭代，然后更新进度以指示当前进度。

    具有进度通知和阻塞呼叫的简单循环

    此示例将前面的示例添加一个阻止调用。 因为阻塞调用可能会引发InterruptedException，并且由于任务被取消的结果可能会发生InterruptedException，所以我们需要确保处理InterruptedException并检查取消状态。 

       Task<Integer> task = new Task<Integer>() { @Override protected Integer call() throws Exception { int iterations; for (iterations = 0; iterations < 1000; iterations++) { if (isCancelled()) { updateMessage("Cancelled"); break; } updateMessage("Iteration " + iterations); updateProgress(iterations, 1000); // Now block the thread for a short time, but be sure // to check the interrupted exception for cancellation! try { Thread.sleep(100); } catch (InterruptedException interrupted) { if (isCancelled()) { updateMessage("Cancelled"); break; } } } return iterations; } };

    这里我们加了一个循环的一个Thread.sleep调用。 由于这是一个阻塞调用，我必须处理潜在的InterruptedException。 在catch块内，我将检查Task是否已经被取消，如果是这样，请相应地更新该消息并从循环中跳出。

    获取参数的任务

    大多数任务需要一些参数才能做有用的工作。 例如，DeleteRecordTask需要从数据库中删除的对象或主键。 ReadFileTask需要读取文件的URI。 由于任务在后台线程上运行，因此必须注意确保call方法的正文不会读取或修改任何共享状态。 有两种最有用的技巧：使用最终变量，并在构建过程中将变量传递给任务。

    当使用Task作为匿名类时，将参数传递给Task的最自然的方法是使用最终变量。 在这个例子中，我们传递任务要迭代的总次数。 

       final int totalIterations = 9000000; Task<Integer> task = new Task<Integer>() { @Override protected Integer call() throws Exception { int iterations; for (iterations = 0; iterations < totalIterations; iterations++) { if (isCancelled()) { updateMessage("Cancelled"); break; } updateMessage("Iteration " + iterations); updateProgress(iterations, totalIterations); } return iterations; } };

    由于totalIterations是最终的，因此call方法可以安全地读取它，并从后台线程中引用它。

    当写任务库（与特定用途实现相反）时，我们需要使用不同的技术。 在这种情况下，我将创建一个执行与上述相同工作的IteratingTask。 这一次，因为IteratingTask是在自己的文件中定义的，所以它需要在其构造函数中传递参数。 这些参数分配给最终变量。 

       public class IteratingTask extends Task<Integer> { private final int totalIterations; public IteratingTask(int totalIterations) { this.totalIterations = totalIterations; } @Override protected Integer call() throws Exception { int iterations = 0; for (iterations = 0; iterations < totalIterations; iterations++) { if (isCancelled()) { updateMessage("Cancelled"); break; } updateMessage("Iteration " + iterations); updateProgress(iterations, totalIterations); } return iterations; } }

    然后使用时： 

       IteratingTask task = new IteratingTask(8000000);

    以这种方式，参数以安全的方式传递给IteratingTask，并且再次是final。 因此， call方法可以从后台线程安全地读取此状态。

    警告：不要将可变状态传递给任务，然后从后台线程中进行操作。 这样做可能会引入种族条件。 特别是，假设您有一个SaveCustomerTask，它在其构造函数中占用了一个客户端。 尽管SaveCustomerTask可能对客户有最终的引用，但如果Customer对象是可变的，那么SaveCustomerTask和其他一些应用程序代码可能会从不同的线程读取或修改Customer的状态。 在这种情况下，要非常小心，因为从后台线程使用诸如此客户端的可变对象时，它不会被另一个线程使用。 特别是，如果后台线程从数据库读取数据并更新Customer对象，并且Customer对象绑定到场景图形节点（如UI控件），那么可能会违反线程规则！ 对于这种情况，请从FX应用程序主题而不是后台线程修改Customer对象。 

       public class UpdateCustomerTask extends Task<Customer> { private final Customer customer; public UpdateCustomerTask(Customer customer) { this.customer = customer; } @Override protected Customer call() throws Exception { // pseudo-code: // query the database // read the values // Now update the customer Platform.runLater(new Runnable() { @Override public void run() { customer.setFirstName(rs.getString("FirstName")); // etc } }); return customer; } }

    一个没有价值的任务

    许多（如果不是大多数）任务应该在完成后返回一个值。 对于CRUD任务，可以预期“创建”任务将返回新创建的对象或主键，“读取”任务将返回读取对象，“更新”任务将返回更新的记录数，并且“删除“任务将返回删除的记录数。

    但是有时候只是没有任何真正有用的回报。 例如，我可能有一个写入文件的任务。 任务已经内置了一个机制，用于指示它是否成功或失败，以及写入的字节数（进度），因此我没有什么真正的返回。 在这种情况下，您可以使用Void类型。 这是Java语言中的一种特殊类型，只能分配null的值。 你会使用它如下： 

       final String filePath = "/foo.txt"; final String contents = "Some contents"; Task<Void> task = new Task<Void>() { @Override protected Void call() throws Exception { File file = new File(filePath); FileOutputStream out = new FileOutputStream(file); // ... and other code to write the contents ... // Return null at the end of a Task of type Void return null; } };

    一个返回一个ObservableList的任务

    因为ListView，TableView和其他UI控件和场景图形节点使用了ObservableList，所以通常要从任务创建并返回一个ObservableList。 当您不关心显示中间值时，正确编写此类任务的最简单方法是在call方法中构造一个ObservableList，然后在任务结束时返回。 

       Task<ObservableList<Rectangle>> task = new Task<ObservableList<Rectangle>>() { @Override protected ObservableList<Rectangle> call() throws Exception { updateMessage("Creating Rectangles"); ObservableList<Rectangle> results = FXCollections.observableArrayList(); for (int i=0; i<100; i++) { if (isCancelled()) break; Rectangle r = new Rectangle(10, 10); r.setX(10 * i); results.add(r); updateProgress(i, 100); } return results; } };

    在上面的例子中，我们要创建100个矩形，并从这个任务返回它们。 在call方法中创建一个ObservableList，填充，然后返回。

    返回部分结果的任务

    有时你想创建一个任务将返回部分结果。 也许您正在构建一个复杂的场景图，并希望在构建场景图时显示场景图。 或者您正在通过网络读取大量数据，并希望在数据到达时在TableView中显示条目。 在这种情况下，FX应用程序线程和后台线程都有一些共享状态。 必须非常小心， 永远不要从外汇应用程序主题以外的任何线程更新共享状态 。

    最简单的方法是利用updateValue(Object)方法。 该方法可以从后台线程重复调用。 更新合并以防止FX事件队列的饱和。 这意味着您可以根据需要从后台线程中频繁地调用它，但只能最后设置。 

       Task<Long> task = new Task<Long>() { @Override protected Long call() throws Exception { long a = 0; long b = 1; for (long i = 0; i < Long.MAX_VALUE; i++) { updateValue(a); a += b; b = a - b; } return a; } };

    另一种方法是在任务上公开一个新属性，这将表示部分结果。 然后在更新部分结果时确保使用Platform.runLater 。 

       Task<Long> task = new Task<Long>() { @Override protected Long call() throws Exception { long a = 0; long b = 1; for (long i = 0; i < Long.MAX_VALUE; i++) { final long v = a; Platform.runLater(new Runnable() { @Override public void run() { updateValue(v); } } a += b; b = a - b; } return a; } };

    假设不是更新单个值，而是要在获取结果时填充一个ObservableList。 一种方法是在任务上公开一个新属性，这将表示部分结果。 然后在部分结果中添加新项目时，请确保使用Platform.runLater 。 

       public class PartialResultsTask extends Task<ObservableList<Rectangle>> { // Uses Java 7 diamond operator private ReadOnlyObjectWrapper<ObservableList<Rectangle>> partialResults = new ReadOnlyObjectWrapper<>(this, "partialResults", FXCollections.observableArrayList(new ArrayList<Rectangle>())); public final ObservableList<Rectangle> getPartialResults() { return partialResults.get(); } public final ReadOnlyObjectProperty<ObservableList<Rectangle>> partialResultsProperty() { return partialResults.getReadOnlyProperty(); } @Override protected ObservableList<Rectangle> call() throws Exception { updateMessage("Creating Rectangles..."); for (int i=0; i<100; i++) { if (isCancelled()) break; final Rectangle r = new Rectangle(10, 10); r.setX(10 * i); Platform.runLater(new Runnable() { @Override public void run() { partialResults.get().add(r); } }); updateProgress(i, 100); } return partialResults.get(); } }

    修改场景图的任务

    通常，任务不应该直接与UI交互。 这样做会在特定的Task实现和UI的特定部分之间产生紧密的耦合。 但是，当您想要创建此类耦合时，您必须确保使用Platform.runLater以便在FX应用程序线程上进行场景图形的任何修改。 

       final Group group = new Group(); Task<Void> task = new Task<Void>() { @Override protected Void call() throws Exception { for (int i=0; i<100; i++) { if (isCancelled()) break; final Rectangle r = new Rectangle(10, 10); r.setX(10 * i); Platform.runLater(new Runnable() { @Override public void run() { group.getChildren().add(r); } }); } return null; } };

    反应一般状态变化

    有时候，您可能想编写一个任务来更新其进度，消息，文本，或者以某种其他方式对任务发生状态更改时做出反应。 例如，您可能希望在失败，成功，运行或取消状态更改任务上更改状态消息。 

       Task<Integer> task = new Task<Integer>() { @Override protected Integer call() throws Exception { int iterations = 0; for (iterations = 0; iterations < 100000; iterations++) { if (isCancelled()) { break; } System.out.println("Iteration " + iterations); } return iterations; } @Override protected void succeeded() { super.succeeded(); updateMessage("Done!"); } @Override protected void cancelled() { super.cancelled(); updateMessage("Cancelled!"); } @Override protected void failed() { super.failed(); updateMessage("Failed!"); } };
    从以下版本开始：
    JavaFX 2.0

    • 构造方法详细信息

      • Task

        public Task​()
        创建一个新的任务。

    • 方法详细信息

      • call

        protected abstract V call​()
                   throws 异常
        在执行任务时调用，调用方法必须被子类覆盖并实现。 调用方法实际上执行后台线程逻辑。 只能使用该方法中的代码来调用Task的updateProgress，updateMessage，updateValue和updateTitle方法。 与后台线程任务的任何其他交互将导致运行时异常。
        结果
        后台工作的结果，如果有的话。
        异常
        异常 - 在后台操作期间发生的未处理的异常

      • getState

        public final Worker.State getState​()
        获取属性状态的值。
        Specified by:
        getState接口 Worker<V>
        Property description:
        结果
        这个工人的现状

      • getOnScheduled

        public final EventHandler<WorkerStateEvent> getOnScheduled​()
        每当任务状态转换到SCHEDULED状态时，调用onSchedule事件处理程序。
        结果
        onScheduled事件处理程序（如果有的话）
        从以下版本开始：
        JavaFX 2.1

      • setOnScheduled

        public final void setOnScheduled​(EventHandler<WorkerStateEvent> value)
        每当任务状态转换到SCHEDULED状态时，调用onSchedule事件处理程序。
        参数
        value - 事件处理程序可以为空清除它
        从以下版本开始：
        JavaFX 2.1

      • scheduled

        protected void scheduled​()
        每当任务的状态已经转换到SCHEDULED状态时调用的子类的受保护的便利方法。 在任务完全转换到新状态之后，FX应用程序线程调用此方法。
        从以下版本开始：
        JavaFX 2.1

      • getOnRunning

        public final EventHandler<WorkerStateEvent> getOnRunning​()
        每当任务状态转换到RUNNING状态时，都会调用onRunning事件处理程序。
        结果
        onRunning事件处理程序（如果有的话）
        从以下版本开始：
        JavaFX 2.1

      • setOnRunning

        public final void setOnRunning​(EventHandler<WorkerStateEvent> value)
        每当任务状态转换到RUNNING状态时，都会调用onRunning事件处理程序。
        参数
        value - 事件处理程序可以为空清除它
        从以下版本开始：
        JavaFX 2.1

      • running

        protected void running​()
        每当任务的状态已经转换到RUNNING状态时调用的子类的受保护的便利方法。 在任务完全转换到新状态之后，FX应用程序线程调用此方法。
        从以下版本开始：
        JavaFX 2.1

      • getOnSucceeded

        public final EventHandler<WorkerStateEvent> getOnSucceeded​()
        每当任务状态转换到SUCCEEDED状态时，调用onSucceeded事件处理程序。
        结果
        onSucceeded事件处理程序（如果有）
        从以下版本开始：
        JavaFX 2.1

      • setOnSucceeded

        public final void setOnSucceeded​(EventHandler<WorkerStateEvent> value)
        每当任务状态转换到SUCCEEDED状态时，调用onSucceeded事件处理程序。
        参数
        value - 事件处理程序可以为空清除它
        从以下版本开始：
        JavaFX 2.1

      • succeeded

        protected void succeeded​()
        每当任务的状态已经转换到SUCCEEDED状态时调用的子类的受保护的便利方法。 在任务完全转换到新状态之后，FX应用程序线程调用此方法。
        从以下版本开始：
        JavaFX 2.1

      • getOnCancelled

        public final EventHandler<WorkerStateEvent> getOnCancelled​()
        每当任务状态转换到CANCELED状态时，都会调用onCancelled事件处理程序。
        结果
        onCancelled事件处理程序（如果有）
        从以下版本开始：
        JavaFX 2.1

      • setOnCancelled

        public final void setOnCancelled​(EventHandler<WorkerStateEvent> value)
        每当任务状态转换到CANCELED状态时，都会调用onCancelled事件处理程序。
        参数
        value - 事件处理程序可以为空清除它
        从以下版本开始：
        JavaFX 2.1

      • cancelled

        protected void cancelled​()
        每当任务的状态已经转换到CANCELED状态时，调用子类的受保护的便利方法。 在任务完全转换到新状态之后，FX应用程序线程调用此方法。
        从以下版本开始：
        JavaFX 2.1

      • getOnFailed

        public final EventHandler<WorkerStateEvent> getOnFailed​()
        每当任务状态转换到FAILED状态时，都会调用onFailed事件处理程序。
        结果
        onFailed事件处理程序（如果有）
        从以下版本开始：
        JavaFX 2.1

      • setOnFailed

        public final void setOnFailed​(EventHandler<WorkerStateEvent> value)
        每当任务状态转换到FAILED状态时，都会调用onFailed事件处理程序。
        参数
        value - 事件处理程序可以为空清除它
        从以下版本开始：
        JavaFX 2.1

      • failed

        protected void failed​()
        每当任务的状态已转换到FAILED状态时调用的子类的受保护的便利方法。 在任务完全转换到新状态之后，FX应用程序线程调用此方法。
        从以下版本开始：
        JavaFX 2.1

      • getValue

        public final V getValue​()
        获取属性值的值。
        Specified by:
        getValue在接口 Worker<V>
        Property description:
        结果
        这个工人的当前值

      • getException

        public final Throwable getException​()
        获取属性异常的值。
        Specified by:
        getException在接口 Worker<V>
        Property description:
        结果
        例外，如果发生

      • totalWorkProperty

        public final ReadOnlyDoubleProperty totalWorkProperty​()
        描述从接口Worker复制
        获取ReadOnlyDoubleProperty代表需要完成的最大工作量。 这些“工作单位”对Worker实现有意义，例如需要下载的字节数或要处理的图像数量或某种其他此类度量。
        Specified by:
        totalWorkProperty在接口 Worker<V>
        另请参见：
        getTotalWork()

      • isRunning

        public final boolean isRunning​()
        获取运行的属性的值。
        Specified by:
        isRunning在接口 Worker<V>
        Property description:
        结果
        如果此Worker正在运行，则为true

      • getMessage

        public final String getMessage​()
        获取属性消息的值。
        Specified by:
        getMessage接口 Worker<V>
        Property description:
        结果
        当前的消息

      • getTitle

        public final String getTitle​()
        获取属性标题的值。
        Specified by:
        getTitle在接口 Worker<V>
        Property description:
        结果
        当前标题

      • cancel

        public final boolean cancel​()
        描述从接口Worker复制
        终止执行这个工人。 调用此方法将从执行队列中删除此Worker或停止执行。
        Specified by:
        cancel在接口 Worker<V>
        结果
        如果取消成功，则返回true

      • cancel

        public boolean cancel​(boolean mayInterruptIfRunning)
        说明从接口Future复制
        尝试取消执行此任务。 如果任务已经完成，已经被取消或由于某种其他原因而无法取消，则此尝试将失败。 如果成功，并且当cancel时此任务尚未启动，则此任务不应运行。 如果任务已经开始，那么mayInterruptIfRunning参数确定执行此任务的线程是否应该中断以试图停止任务。

        此方法返回后，对Future.isDone()的后续调用将始终返回true 。 对后续调用Future.isCancelled()总是返回true如果此方法返回true 。

        Specified by:
        cancel在接口 Future<V>
        重写：
        cancel在 FutureTask<V>
        参数
        mayInterruptIfRunning - true如果执行该任务的线程应该被中断; 否则，正在进行的任务被允许完成
        结果
        false如果任务无法取消，通常是因为它已经正常完成; 否则为true

      • updateProgress

        protected void updateProgress​(long workDone,
                              long max)
        更新workDone ， totalWork ，并progress性能。 对updateProgress的调用在FX应用程序线程上合并并运行，即使从FX应用程序线程调用updateProgress也不一定会立即更新这些属性，并且可以将中间的workDone值合并以保存事件通知。 max成为新的价值totalWork 。

        这种方法可以安全地从任何线程调用。

        参数
        workDone - 从Long.MIN_VALUE到最大值的值 如果该值大于max，则将被钳位在最大值。 如果传递的值为负值，则所得到的完成百分比将为-1（因此，不确定）。
        max - 从Long.MIN_VALUE到Long.MAX_VALUE的值。
        另请参见：
        updateProgress(double, double)

      • updateProgress

        protected void updateProgress​(double workDone,
                              double max)
        更新workDone ， totalWork ，并progress性能。 对updateProgress的调用在FX应用程序线程上合并并运行，即使从FX应用程序线程调用updateProgress也不一定会立即更新这些属性，并且可以将中间的workDone值合并以保存事件通知。 max成为新的价值totalWork 。

        这种方法可以安全地从任何线程调用。

        参数
        workDone - 从Double.MIN_VALUE到最大值的值 如果该值大于max，则将被钳位在最大值。 如果传递的值为负数，则为无穷大或NaN，则所得到的percentDone将为-1（因此，不确定）。
        max - 从Double.MIN_VALUE到Double.MAX_VALUE的值。 无穷大和NaN处理为-1。
        从以下版本开始：
        JavaFX 2.2

      • updateMessage

        protected void updateMessage​(String message)
        更新message属性。 对updateMessage的调用在FX应用程序线程上合并并运行，因此甚至从FX应用程序线程调用updateMessage可能不一定会立即更新此属性，并且可以将中间消息值合并以保存事件通知。

        这种方法可以安全地从任何线程调用。

        参数
        message - 新消息

      • updateTitle

        protected void updateTitle​(String title)
        更新title属性。 对updateTitle的调用在FX应用程序线程上合并并运行，因此甚至从FX应用程序线程调用updateTitle可能不一定会立即更新此属性，并且中间标题值可能会合并以保存事件通知。

        这种方法可以安全地从任何线程调用。

        参数
        title - 新标题

      • updateValue

        protected void updateValue​(V value)
        更新value属性。 对updateValue的调用在FX应用程序线程上合并并运行，因此甚至从FX应用程序线程调用updateValue可能不一定会立即更新此属性，并且可以将中间值合并以保存事件通知。

        这种方法可以安全地从任何线程调用。

        参数
        value - 新值
        从以下版本开始：
        JavaFX 8.0

      • addEventHandler

        public final <T extends Event> void addEventHandler​(EventType<T> eventType,
                                                    EventHandler<? super T> eventHandler)
        注册一个事件处理程序到这个任务。 首先处理任何事件过滤器，然后处理指定的onFoo事件处理程序，最后处理通过此方法注册的任何事件处理程序。 与场景图中的其他事件一样，如果事件被消耗，则不会继续调度。
        参数类型
        T - 处理程序的特定事件类
        参数
        eventType - 由处理程序接收的事件的类型
        eventHandler - 要注册的处理程序
        异常
        NullPointerException - 如果事件类型或处理程序为空
        从以下版本开始：
        JavaFX 2.1

      • removeEventHandler

        public final <T extends Event> void removeEventHandler​(EventType<T> eventType,
                                                       EventHandler<? super T> eventHandler)
        从此任务中注销先前注册的事件处理程序。 一个处理程序可能已被注册用于不同的事件类型，因此调用者需要指定特定的事件类型，从中注销处理程序。
        参数类型
        T - 处理程序的特定事件类
        参数
        eventType - 要注销的事件类型
        eventHandler - 要注销的处理程序
        异常
        NullPointerException - 如果事件类型或处理程序为空
        从以下版本开始：
        JavaFX 2.1

      • addEventFilter

        public final <T extends Event> void addEventFilter​(EventType<T> eventType,
                                                   EventHandler<? super T> eventFilter)
        将事件过滤器注册到此任务。 注册事件过滤器在任何关联的事件处理程序之前获取事件。
        参数类型
        T - 过滤器的特定事件类
        参数
        eventType - 过滤器接收的事件的类型
        eventFilter - 要注册的过滤器
        异常
        NullPointerException - 如果事件类型或过滤器为空
        从以下版本开始：
        JavaFX 2.1

      • removeEventFilter

        public final <T extends Event> void removeEventFilter​(EventType<T> eventType,
                                                      EventHandler<? super T> eventFilter)
        从此任务中注销先前注册的事件过滤器。 一个过滤器可能已被注册用于不同的事件类型，因此调用者需要指定特定的事件类型，从中注销过滤器。
        参数类型
        T - 过滤器的特定事件类
        参数
        eventType - 要注销的事件类型
        eventFilter - 要注销的过滤器
        异常
        NullPointerException - 如果事件类型或过滤器为空
        从以下版本开始：
        JavaFX 2.1

      • setEventHandler

        protected final <T extends Event> void setEventHandler​(EventType<T> eventType,
                                                       EventHandler<? super T> eventHandler)
        设置要用于此事件类型的处理程序。 一次只能有一个这样的处理程序。 这个处理程序被保证被首先调用。 这用于注册用户定义的onFoo事件处理程序。
        参数类型
        T - 处理程序的特定事件类
        参数
        eventType - 与给定eventHandler关联的事件类型
        eventHandler - 要注册的处理程序，或者取消注册为null
        异常
        NullPointerException - 如果事件类型为空
        从以下版本开始：
        JavaFX 2.1

      • fireEvent

        public final void fireEvent​(Event event)
        触发指定的事件。 遇到的任何事件过滤器将被通知并可以使用该事件。 如果没有被过滤器使用，则会通知此任务上的事件处理程序。 如果这些也不消耗事件，那么所有事件处理程序都被调用，并且可以使用该事件。

        必须在FX用户线程上调用此方法。

        参数
        event - 事件发生
        从以下版本开始：
        JavaFX 2.1

      • buildEventDispatchChain

        public EventDispatchChain buildEventDispatchChain​(EventDispatchChain tail)
        描述从接口EventTarget复制
        为此目标构建事件调度链。 事件调度链包含可能对处理针对EventTarget的事件感兴趣的事件调度EventTarget 。 此事件目标不会自动添加到链中，因此如果要处理事件，则需要为链接添加一个EventDispatcher 。

        在事件目标是某些层次结构的一部分的情况下，它的链通常是从从层次结构的根被收集到事件目标的事件分派器构建的。

        事件调度链是通过修改提供的初始事件调度链来构建的。 返回的链应该在其末端具有初始链，所以调度员应该放在初始链上。

        调用者不应该假定初始链条保持不变，也不会返回值引用不同的链。

        Specified by:
        buildEventDispatchChain在接口 EventTarget
        参数
        tail - 建立起来的初始链
        结果
        此目标的结果事件调度链