モジュール javafx.graphics
パッケージ javafx.concurrent

クラスTask<V>

  • すべての実装されたインタフェース:
    Runnable, Future<V>, RunnableFuture<V>, Worker<V>, EventTarget
    public abstract class Task<V>
extends FutureTask<V>
implements Worker<V>, EventTarget

    FutureTaskの完全に監視可能な実装。 Taskは、Workerインタフェースで定義されているように、JavaFXで非同期タスクのプログラミングに役立つ追加の状態および観測可能なプロパティを公開します。 Taskの実装は、call()メソッドをオーバーライドする必要があります。 このメソッドはバックグラウンド・スレッドで呼び出されます。 このメソッドで使用される状態は、バックグラウンド・スレッドからの読取りおよび書込みに対して安全である必要があります。 たとえば、このメソッドから実行中のシーン・グラフを操作することは安全ではなく、ランタイム例外になります。

    Taskには柔軟性があり、処理のカプセル化に非常に有用です。 ServiceはTaskを実行するように設計されているため、アプリケーションまたはライブラリ・コードによって定義されたTaskは、Serviceで簡単に使用できます。 同様に、TaskはFutureTaskから拡張されているため、TaskをjavaコンカレンシーExecutor APIで使用することは、非常に簡単で自然です。 TaskはRunnableなので、別のバックグラウンド・スレッドから直接(RunnableFuture.run()メソッドを呼び出すことによって)を呼び出すこともできます。 これにより処理のコンポジションが可能になり、または手動で構築および実行された新しいThreadにそれを渡します。 最後に、新しいThreadを手動で作成してそれにRunnableを渡すことができるため、次のイディオムを使用できます。 

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

    このコードはThreadのデーモン・フラグをtrueに設定することに注意してください。 最後の段階が閉じられた後にバックグラウンド・スレッドがVMを終了させないようにするには、デーモンをfalseにします。 ただし、すべてのステージがクローズされた後にバックグラウンド・スレッドを単純に終了する場合は、デーモンをtrueに設定する必要があります。

    ExecutorServiceはRunnableをとる複数のメソッドを定義しますが、一般的にはExecutorから継承されたexecuteメソッドの使用に制限する必要があります。

    FutureTaskと同様に、Taskはワンショット・クラスであり再利用できません。 再利用可能なWorkerについては、Serviceを参照してください。

    TaskはJavaFX GUIアプリケーションで使用するように設計されているため、publicプロパティに対するすべての変更や、状態、エラーおよびイベント・ハンドラに関する変更通知は、すべてメインのJavaFXアプリケーション・スレッド上で発生することが保証されます。 これらのプロパティにバックグラウンド・スレッド(call()メソッドを含む)からアクセスすると、ランタイム例外が発生します。 これに該当しないのはTaskを最初に構成する場合のみであり、これは任意のスレッドから安全に実行できます。 ただし、Taskが初期化および起動されると、以降はFXスレッドからのみ使用できます(サブクラスがバックグラウンド・スレッドから起動することが適切であると明確に示されているメソッドを除きます)。

    Taskが動作する不変の状態ですべてのTaskを初期化することをお薦めします。 これは、Taskの実行に必要なパラメータをとるTaskコンストラクタを提供することで実行する必要があります。 不変の状態によって、任意のスレッドからの使用が簡単で安全になり、複数のスレッドがある場合の正しさが確保されます。

    Javaでは、プロセス内のスレッドを確実に強制終了する方法はありません。 ただし、Taskでcancelが呼び出される場合、Taskが処理を停止することが重要です。 ランナウェイ・タスクは、Taskが取り消された後も、message、textおよびprogressプロパティの処理および更新を続行する可能性があります。 Javaでは、Taskの取消しは協調的に試行されます。 Taskのユーザーが取消しを要求し、Taskの作成者がcallメソッドの本体で取り消されたかどうかをチェックする必要があります。 これを行うには、2つの方法があります。 最初に、Task作成者はFutureTaskから継承されたisCancelledメソッドをチェックして、Taskが取り消されたかどうかを確認できます。 次に、Task実装がブロッキング呼出し(NIO InterruptibleChannelsやThread.sleepなど)を使用しており、そのようなブロッキング呼出し中にタスクが取り消される場合は、InterruptedExceptionがスローされます。 ブロッキング呼出しを含むTask実装は、中断されたスレッドがタスクが取り消されたことを示している可能性があることを認識し、isCancelledメソッドを再確認して、Taskの取消しによってInterruptedExceptionがスローされたことを確認します。

    例

    次の一連の例では、Taskの最も一般的な使用方法のいくつかを示します。

    単純なループ

    最初の例は、特に有用なことは何も行いませんが、Taskを正しく記述することの基本的な側面を示す単純なループです。 この例では、単純にループして、ループの反復ごとに標準出力に出力します。 完了すると、反復した回数を返します。 

    
     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から返される値のタイプを定義します。 この場合は、反復した回数を返すため、総称型を使用してTaskがタイプIntegerであることを指定します。 次に、callメソッドの実装内で、0から100000まで反復します。 反復ごとに、このTaskが取り消されたかどうかを確認します。 該当する場合は、ループを抜けて反復した回数を返します。 それ以外の場合は、メッセージがコンソールに出力され、反復回数が増加し、ループが続行されます。

    ループ本体でのisCancelled()のチェックは重要であり、これを実行しないと、開発者がタスクを取り消す場合がありますが、タスクは引き続き実行され、両方の進捗を更新してcallメソッドの最後から誤った結果を返します。 Taskの正しい実装では、取消しを常にチェックします。

    進捗の通知を含む単純なループ

    前の例と似ていますが、ここでは反復ごとのTaskの進捗を変更します。 取消しの場合に選択肢があることに注意してください。 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が取り消されたかどうかをチェックします。 取り消された場合は、Taskのメッセージを更新して取り消されたことを示し、前と同様に中断します。 Taskが取り消されていない場合は、そのメッセージを更新して現在の反復を示し、進捗を更新して現在の進捗を示します。

    進捗の通知およびブロッキング・コールを含む単純なループ

    この例では、前の例にブロッキング・コールを追加します。 ブロッキング・コールはInterruptedExceptionをスローする場合があり、またInterruptedExceptionはTaskの取消しの結果として発生する場合があるため、確実に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が取り消されたかどうかをチェックし、取り消された場合はそのようにメッセージを更新してループを抜けます。

    パラメータをとるTask

    有用な処理を実行するために、ほとんどのTaskにはパラメータが必要です。 たとえば、DeleteRecordTaskには、データベースから削除するオブジェクトまたは主キーが必要です。 ReadFileTaskには、読み取るファイルのURIが必要です。 Taskはバックグラウンド・スレッドで動作するため、callメソッドの本体が、共有された状態を読み取ったり変更しないように注意する必要があります。 これを行うために最も有用な2つの手法があり、それらはfinal変数の使用と、構築中に変数をTaskに渡すことです。

    Taskを匿名クラスとして使用する場合、Taskにパラメータを渡す最も自然な方法は、final変数の使用です。 この例では、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はfinalであるため、callメソッドはそれを安全に読み取り、バックグラウンド・スレッドから参照できます。

    (特定用途の実装ではなく) Taskライブラリを記述する場合は、異なる手法を使用する必要があります。 この場合は、前述したのと同じ処理を実行するIteratingTaskを作成します。 今度は、IteratingTaskは固有のファイル内に定義されるため、そのコンストラクタで渡されるパラメータが必要です。 これらのパラメータはfinal変数に割り当てられます。 

    
     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メソッドはこの状態をバックグラウンド・スレッドから安全に読み取ることができます。

    警告: 可変の状態をTaskに渡してそれをバックグラウンド・スレッドから操作しないでください。 これを実行すると、競合状態が発生する場合があります。 たとえば、コンストラクタ内のCustomerをとるSaveCustomerTaskがあるとします。 SaveCustomerTaskにCustomerへのfinal参照がある場合がありますが、Customerオブジェクトが可変である場合、SaveCustomerTaskと他のアプリケーション・コードの両方が異なるスレッドからCustomerの状態を読み取ったり変更している可能性があります。 このような場合、この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;
         }
     }

    値を返さないTask

    ほとんどではないにしても、多くのTaskは完了時に値を返します。 CRUDタスクでは、作成タスクは新しく作成されたオブジェクトまたは主キーを返し、読取りタスクは読取りオブジェクトを返し、更新タスクは更新されたレコード数を返し、削除タスクは削除されたレコード数を返すことが予期されます。

    ただし、返すことが有用なものが何もない場合があります。 たとえば、ファイルに書き込むTaskがあるとします。 Taskには、成功したか失敗したか、および書き込まれたバイト数(進捗)を示すためのメカニズムが組み込まれており、返すものはありません。 そのような場合は、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を返すTask

    ListView、TableViewおよびその他のUIコントロールとシーン・グラフ・ノードではObservableListが使用されるため、TaskからObservableListを作成して返すことは一般的です。 中間値を表示しない場合、そのようなTaskを正しく記述する最も簡単な方法は、単純にcallメソッド内でObservableListを構築し、Taskの最後でそれを返すことです。 

    
     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個の矩形を作成してこのタスクから返します。 ObservableListはcallメソッド内で作成され、移入され、返されます。

    結果の一部を返すTask

    結果の一部を返すTaskを作成する場合があります。 複雑なシーン・グラフを構築しており、構築中のシーン・グラフを表示します。 または、大量のデータをネットワーク経由で読み取っており、データの到着にあわせてエントリをTableViewで表示します。 そのような場合、FXアプリケーション・スレッドとバックグラウンド・スレッドの両方で使用できる共有された状態があります。 共有された状態を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;
         }
     };

    これを行う別の方法は、結果の一部を表す新しいプロパティをTaskで公開することです。 その場合、結果の一部を更新するときは必ず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;
         }
     };

    1つの値を更新するのではなく、結果が取得されるのにあわせてObservableListに移入するとします。 1つの方法は、結果の一部を表す新しいプロパティをTaskで公開することです。 その場合、新しい項目を結果の一部に追加するときは必ず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();
         }
     }

    シーン・グラフを変更するTask

    一般に、TaskはUIと直接はやり取りしません。 これを行うと、特定のTask実装とUIの特定の部分との間に密結合が作成されます。 ただし、そのような結合を作成する場合は、シーン・グラフの変更がFXアプリケーション・スレッドで発生するように、必ずPlatform.runLaterを使用する必要があります。 

    
     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で状態変更が発生するたびに、その進捗、メッセージ、テキストを更新するTask、または別の方法で対応するTaskを記述する場合があります。 たとえば、Failure、Success、RunningまたはCancelled状態の変更時に、Taskでステータス・メッセージを変更する場合があります。 

    
     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()
        新しいTaskを作成します。

    • メソッドの詳細

      • call

        protected abstract V call()
                   throws Exception
        Taskが実行されるときに呼び出され、callメソッドはサブクラスによってオーバーライドおよび実装される必要があります。 callメソッドは、実際にはバックグラウンド・スレッド・ロジックを実行します。 TaskのupdateProgress、updateMessage、updateValueおよびupdateTitleメソッドのみを、このメソッド内のコードから呼び出すことができます。 バックグラウンド・スレッドからのTaskとのその他のやり取りは、ランタイム例外になります。
        戻り値:
        バックグラウンド処理の結果(存在する場合)
        例外:
        Exception - バックグラウンド操作中に発生した未処理の例外

      • getOnScheduled

        public final EventHandler<WorkerStateEvent> getOnScheduled()
        Task状態遷移がSCHEDULED状態になるたびにonScheduleイベント・ハンドラが呼び出されます。
        戻り値:
        onScheduledイベント・ハンドラ(存在する場合)
        導入されたバージョン:
        JavaFX 2.1

      • setOnScheduled

        public final void setOnScheduled​(EventHandler<WorkerStateEvent> value)
        Task状態遷移がSCHEDULED状態になるたびにonScheduleイベント・ハンドラが呼び出されます。
        パラメータ:
        value - イベント・ハンドラ(nullにしてクリアすることが可能)
        導入されたバージョン:
        JavaFX 2.1

      • scheduled

        protected void scheduled()
        Taskの状態がSCHEDULED状態に遷移するたびに呼び出される、サブクラスのprotectedコンビニエンス・メソッド。 このメソッドは、Taskが新しい状態に完全に遷移した後にFXアプリケーション・スレッドで呼び出されます。
        導入されたバージョン:
        JavaFX 2.1

      • getOnRunning

        public final EventHandler<WorkerStateEvent> getOnRunning()
        Task状態遷移がRUNNING状態になるたびにonRunningイベント・ハンドラが呼び出されます。
        戻り値:
        onRunningイベント・ハンドラ(存在する場合)
        導入されたバージョン:
        JavaFX 2.1

      • setOnRunning

        public final void setOnRunning​(EventHandler<WorkerStateEvent> value)
        Task状態遷移がRUNNING状態になるたびにonRunningイベント・ハンドラが呼び出されます。
        パラメータ:
        value - イベント・ハンドラ(nullにしてクリアすることが可能)
        導入されたバージョン:
        JavaFX 2.1

      • running

        protected void running()
        Taskの状態がRUNNING状態に遷移するたびに呼び出される、サブクラスのprotectedコンビニエンス・メソッド。 このメソッドは、Taskが新しい状態に完全に遷移した後にFXアプリケーション・スレッドで呼び出されます。
        導入されたバージョン:
        JavaFX 2.1

      • getOnSucceeded

        public final EventHandler<WorkerStateEvent> getOnSucceeded()
        Task状態遷移がSUCCEEDED状態になるたびにonSucceededイベント・ハンドラが呼び出されます。
        戻り値:
        onSucceededイベント・ハンドラ(存在する場合)
        導入されたバージョン:
        JavaFX 2.1

      • setOnSucceeded

        public final void setOnSucceeded​(EventHandler<WorkerStateEvent> value)
        Task状態遷移がSUCCEEDED状態になるたびにonSucceededイベント・ハンドラが呼び出されます。
        パラメータ:
        value - イベント・ハンドラ(nullにしてクリアすることが可能)
        導入されたバージョン:
        JavaFX 2.1

      • succeeded

        protected void succeeded()
        Taskの状態がSUCCEEDED状態に遷移するたびに呼び出される、サブクラスのprotectedコンビニエンス・メソッド。 このメソッドは、Taskが新しい状態に完全に遷移した後にFXアプリケーション・スレッドで呼び出されます。
        導入されたバージョン:
        JavaFX 2.1

      • getOnCancelled

        public final EventHandler<WorkerStateEvent> getOnCancelled()
        Task状態遷移がCANCELLED状態になるたびにonCancelledイベント・ハンドラが呼び出されます。
        戻り値:
        onCancelledイベント・ハンドラ(存在する場合)
        導入されたバージョン:
        JavaFX 2.1

      • setOnCancelled

        public final void setOnCancelled​(EventHandler<WorkerStateEvent> value)
        Task状態遷移がCANCELLED状態になるたびにonCancelledイベント・ハンドラが呼び出されます。
        パラメータ:
        value - イベント・ハンドラ(nullにしてクリアすることが可能)
        導入されたバージョン:
        JavaFX 2.1

      • cancelled

        protected void cancelled()
        Taskの状態がCANCELLED状態に遷移するたびに呼び出される、サブクラスのprotectedコンビニエンス・メソッド。 このメソッドは、Taskが新しい状態に完全に遷移した後にFXアプリケーション・スレッドで呼び出されます。
        導入されたバージョン:
        JavaFX 2.1

      • getOnFailed

        public final EventHandler<WorkerStateEvent> getOnFailed()
        Task状態遷移がFAILED状態になるたびにonFailedイベント・ハンドラが呼び出されます。
        戻り値:
        onFailedイベント・ハンドラ(存在する場合)
        導入されたバージョン:
        JavaFX 2.1

      • setOnFailed

        public final void setOnFailed​(EventHandler<WorkerStateEvent> value)
        Task状態遷移がFAILED状態になるたびにonFailedイベント・ハンドラが呼び出されます。
        パラメータ:
        value - イベント・ハンドラ(nullにしてクリアすることが可能)
        導入されたバージョン:
        JavaFX 2.1

      • failed

        protected void failed()
        Taskの状態がFAILED状態に遷移するたびに呼び出される、サブクラスのprotectedコンビニエンス・メソッド。 このメソッドは、Taskが新しい状態に完全に遷移した後にFXアプリケーション・スレッドで呼び出されます。
        導入されたバージョン:
        JavaFX 2.1

      • totalWorkProperty

        public final ReadOnlyDoubleProperty totalWorkProperty()
        次のインタフェースからコピーされた説明: Worker
        実行する必要がある最大処理量を表すReadOnlyDoublePropertyを取得します。 これらの処理単位は、ダウンロードする必要があるバイト数や処理するイメージ数、その他のこのようなメトリックなど、Worker実装にとって意味を持ちます。
        定義:
        totalWorkProperty 、インタフェース: Worker<V>
        関連項目:
        Worker.getTotalWork()

      • updateProgress

        protected void updateProgress​(long workDone,
                              long max)
        workDone、totalWorkおよびprogressプロパティを更新します。 updateProgressの呼出しは結合されて後でFXアプリケーション・スレッドで実行され、updateProgressの呼出しはFXアプリケーション・スレッドからであっても必ずしもこれらのプロパティの即時更新にはならない場合があり、中間のworkDone値はイベント通知を軽減するために結合される場合があります。maxがtotalWorkの新しい値になります。

        このメソッドは、任意のスレッドから安全に呼び出すことができます。

        パラメータ:
        workDone - Long.MIN_VALUEからmaxまでの値。値がmaxよりも大きい場合は、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アプリケーション・スレッドで実行され、updateProgressの呼出しはFXアプリケーション・スレッドからであっても必ずしもこれらのプロパティの即時更新にはならない場合があり、中間のworkDone値はイベント通知を軽減するために結合される場合があります。maxがtotalWorkの新しい値になります。

        このメソッドは、任意のスレッドから安全に呼び出すことができます。

        パラメータ:
        workDone - Double.MIN_VALUEからmaxまでの値。値がmaxよりも大きい場合は、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アプリケーション・スレッドで実行されるため、updateMessageの呼出しはFXアプリケーション・スレッドからであっても必ずしもこのプロパティの即時更新にはならない場合があり、中間のmessage値はイベント通知を軽減するために結合される場合があります。

        このメソッドは、任意のスレッドから安全に呼び出すことができます。

        パラメータ:
        message - 新しいメッセージ

      • updateTitle

        protected void updateTitle​(String title)
        titleプロパティを更新します。 updateTitleの呼出しは結合されて後でFXアプリケーション・スレッドで実行されるため、updateTitleの呼出しはFXアプリケーション・スレッドからであっても必ずしもこのプロパティの即時更新にはならない場合があり、中間のtitle値はイベント通知を軽減するために結合される場合があります。

        このメソッドは、任意のスレッドから安全に呼び出すことができます。

        パラメータ:
        title - 新しいタイトル

      • updateValue

        protected void updateValue​(V value)
        valueプロパティを更新します。 updateValueの呼出しは結合されて後でFXアプリケーション・スレッドで実行されるため、updateValueの呼出しはFXアプリケーション・スレッドからであっても必ずしもこのプロパティの即時更新にはならない場合があり、中間値はイベント通知を軽減するために結合される場合があります。

        このメソッドは、任意のスレッドから安全に呼び出すことができます。

        パラメータ:
        value - 新しい値
        導入されたバージョン:
        JavaFX 8.0

      • addEventHandler

        public final <T extends Event> void addEventHandler​(EventType<T> eventType,
                                                    EventHandler<? super T> eventHandler)
        このタスクにイベント・ハンドラを登録します。 イベント・フィルタが最初に処理されてから、指定されたonFooイベント・ハンドラ、最後にこのメソッドによって登録されたイベント・ハンドラが処理されます。 シーン・グラフの他のイベントと同様に、イベントが使用されると、ディスパッチは続行されなくなります。
        型パラメータ:
        T - ハンドラの特定のイベント・クラス
        パラメータ:
        eventType - ハンドラが受け取るイベントのタイプ
        eventHandler - 登録するハンドラ
        例外:
        NullPointerException - イベント・タイプまたはハンドラがnullの場合
        導入されたバージョン:
        JavaFX 2.1

      • removeEventHandler

        public final <T extends Event> void removeEventHandler​(EventType<T> eventType,
                                                       EventHandler<? super T> eventHandler)
        以前に登録したイベント・ハンドラをこのタスクから登録解除します。 1つのハンドラが複数の異なるイベント・タイプに登録されているため、呼出し元はハンドラを登録解除する特定のイベント・タイプを指定する必要があります。
        型パラメータ:
        T - ハンドラの特定のイベント・クラス
        パラメータ:
        eventType - 登録解除するイベント・タイプ
        eventHandler - 登録解除するハンドラ
        例外:
        NullPointerException - イベント・タイプまたはハンドラがnullの場合
        導入されたバージョン:
        JavaFX 2.1

      • addEventFilter

        public final <T extends Event> void addEventFilter​(EventType<T> eventType,
                                                   EventHandler<? super T> eventFilter)
        このタスクにイベント・フィルタを登録します。 登録されたイベント・フィルタは、関連付けられたイベント・ハンドラよりも前にイベントを取得します。
        型パラメータ:
        T - フィルタの特定のイベント・クラス
        パラメータ:
        eventType - フィルタが受け取るイベントのタイプ
        eventFilter - 登録するフィルタ
        例外:
        NullPointerException - イベント・タイプまたはフィルタがnullの場合
        導入されたバージョン:
        JavaFX 2.1

      • removeEventFilter

        public final <T extends Event> void removeEventFilter​(EventType<T> eventType,
                                                      EventHandler<? super T> eventFilter)
        以前に登録したイベント・フィルタをこのタスクから登録解除します。 1つのフィルタが複数の異なるイベント・タイプに登録されているため、呼出し元はフィルタを登録解除する特定のイベント・タイプを指定する必要があります。
        型パラメータ:
        T - フィルタの特定のイベント・クラス
        パラメータ:
        eventType - 登録解除するイベント・タイプ
        eventFilter - 登録解除するフィルタ
        例外:
        NullPointerException - イベント・タイプまたはフィルタがnullの場合
        導入されたバージョン:
        JavaFX 2.1

      • setEventHandler

        protected final <T extends Event> void setEventHandler​(EventType<T> eventType,
                                                       EventHandler<? super T> eventHandler)
        このイベント・タイプに使用するハンドラを設定します。 一度に指定できるそのようなハンドラは1つのみです。 このハンドラは、最初に呼び出されることが保証されます。 これは、ユーザー定義のonFooイベント・ハンドラを登録するために使用されます。
        型パラメータ:
        T - ハンドラの特定のイベント・クラス
        パラメータ:
        eventType - 指定のeventHandlerに関連付けるイベント・タイプ
        eventHandler - 登録するハンドラ、または登録解除する場合はnull
        例外:
        NullPointerException - イベント・タイプがnullの場合
        導入されたバージョン:
        JavaFX 2.1

      • fireEvent

        public final void fireEvent​(Event event)
        指定したイベントを起動します。 検出されたイベント・フィルタに通知され、イベント・フィルタはイベントを使用できます。 フィルタが使用しない場合は、このタスクのイベント・ハンドラに通知されます。 これらもイベントを使用しない場合は、すべてのイベント・ハンドラが呼び出されてイベントを使用できます。

        このメソッドは、FXユーザー・スレッドで呼び出される必要があります。

        パラメータ:
        event - 起動するイベント
        導入されたバージョン:
        JavaFX 2.1