Класс Task<V>

Полностью наблюдаемая реализация FutureTask. Task предоставляет дополнительное состояние и наблюдаемые свойства, полезные для программирования асинхронных задач в JavaFX, как определено в интерфейсе Worker. Реализация Task должна переопределить метод call(). Этот метод вызывается в фоновом потоке. Любое состояние, используемое в этом методе, должно быть безопасно для чтения и записи из фонового потока. Например, манипулирование живой графической сценой из этого метода небезопасно и приведет к исключениям во время выполнения.

Задачи гибкие и чрезвычайно полезны для инкапсуляции «работы». Поскольку Service предназначен для выполнения Task, любые задачи, определенные кодом приложения или библиотеки, легко могут быть использованы с Service. Аналогично, так как Task расширяет FutureTask, очень легко и естественно использовать Task с API конкурентного программирования Java Executor. Поскольку Task реализует Runnable, вы также можете вызвать его напрямую (вызвав метод FutureTask.run()) из другого фонового потока. Это позволяет для композиции работы или передачи ее в новый созданный и выполненный вручную поток. Наконец, поскольку вы можете вручную создать новый поток, передав ему Runnable, можно использовать следующий фрагмент кода:

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

Обратите внимание, что этот код устанавливает флаг демон-потока в true. Если вы хотите, чтобы фоновый поток предотвращал выход VM после закрытия последней стадии, то вам нужно установить daemon в false. Однако, если вы хотите, чтобы фоновые потоки просто завершились после закрытия всех стадий, то вам нужно установить daemon в true.

Хотя ExecutorService определяет несколько методов, принимающих Runnable, вам обычно следует ограничиться использованием метода execute, унаследованного от Executor.

Как и FutureTask, Task — это одноразовый класс и не может быть повторно использован. См. Service для повторно используемого Worker.

Поскольку Task предназначен для использования с приложениями JavaFX GUI, он гарантирует, что каждое изменение его общедоступных свойств, а также уведомления о состоянии, ошибках и обработчиках событий происходят в главном потоке JavaFX приложения. Доступ к этим свойствам из фонового потока (включая метод call()) приведет к возникновению исключений во время выполнения. Единственное исключение из этого правила — первоначальная настройка Task, которая может безопасно выполняться из любого потока. Однако после инициализации и запуска Task она может использоваться только из потока FX (за исключением тех методов, которые явно помечены как подходящие для вызова подклассом из фонового потока).

Настоятельно рекомендуется, чтобы все Task инициализировались неизменяемым состоянием, на котором будет работать Task. Это должно быть сделано путем предоставления конструктора Task, который принимает параметры, необходимые для выполнения Task. Неизменяемое состояние упрощает и обеспечивает безопасность использования из любого потока и гарантирует корректность при наличии нескольких потоков.

В Java нет надежного способа «убить» поток в процессе. Однако, когда вызывается метод cancel для Task, важно, чтобы Task прекратил обработку. «Неуправляемая» задача может продолжать обработку и обновление свойств сообщения, текста и прогресса даже после отмены Task! В Java отмена Task — это совместное усилие. Пользователь Task запросит отмену, и автор Task должен проверить, была ли отмена внутри тела метода call. Это можно сделать двумя способами. Во-первых, автор Task может проверить метод isCancelled, унаследованный от FutureTask, чтобы узнать, была ли задача отменена. Во-вторых, если реализация Task использует какие-либо блокирующие вызовы (например, NIO InterruptibleChannels или Thread.sleep) и задача отменяется во время такого блокирующего вызова, выбрасывается InterruptedException. Реализации Task, использующие блокирующие вызовы, должны понимать, что прерванный поток может быть сигналом об отмене задачи, и должны дважды проверить метод isCancelled, чтобы убедиться, что InterruptedException был вызван из-за отмены Task.

Примеры

Следующий набор примеров демонстрирует некоторые из наиболее распространенных способов использования 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 как тип Integer с помощью дженериков. Затем внутри реализации метода call мы итерируем от 0 до 100000. На каждой итерации мы проверяем, была ли эта задача отменена. Если она была, то мы выходим из цикла и возвращаем количество итераций. В противном случае сообщение выводится в консоль, счетчик итераций увеличивается, и мы продолжаем цикл.

Проверка isCancelled() в теле цикла имеет решающее значение; в противном случае разработчик может отменить задачу, но задача продолжит выполняться и обновлять прогресс, возвращая неверный результат из конца метода call. Правильная реализация Task всегда проверяет отмену.

Простой цикл с уведомлениями о прогрессе

Аналогично предыдущему примеру, но на этот раз мы изменим прогресс Task на каждой итерации. Обратите внимание, что у нас есть выбор в случае отмены. Хотим ли мы установить прогресс обратно в -1 (неопределенный) при отмене Task или хотим оставить прогресс на месте? В этом случае давайте оставим прогресс неизменным и обновим только сообщение об отмене, хотя обновление прогресса после отмены — это вполне допустимый выбор.

     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 не была отменена, мы обновим ее сообщение, указав текущую итерацию, и обновим прогресс, указав текущий прогресс.

Простой цикл с уведомлениями о прогрессе и блокирующими вызовами

Этот пример добавляет к предыдущим примерам блокирующий вызов. Поскольку блокирующий вызов может вызвать 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 файла, который нужно прочитать. Поскольку Task работают в фоновом потоке, необходимо позаботиться о том, чтобы тело метода call не считывало и не изменяло общее состояние. Два наиболее полезных подхода для этого: использование конечных переменных и передача переменных в Task во время построения.

При использовании 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 может безопасно прочитать и сослаться на него из фонового потока.

При написании библиотек Task (в отличие от реализаций для конкретного использования) нам нужно использовать другой подход. В этом случае я создам 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 безопасным способом, и снова являются конечными. Таким образом, метод call может безопасно прочитать это состояние из фонового потока.

ПРЕДУПРЕЖДЕНИЕ: Не передавайте изменяемое состояние в Task и затем работайте с ним из фонового потока. Это может привести к возникновению гонок. В частности, предположим, что у вас есть SaveCustomerTask, который принимает Customer в конструкторе. Хотя SaveCustomerTask может иметь конечную ссылку на Customer, если объект Customer изменяемый, то существует вероятность того, что как SaveCustomerTask, так и некоторый другой код приложения будут читать или изменять состояние Customer из разных потоков. Будьте очень осторожны в таких случаях, когда изменяемый объект, такой как Customer, используется из фонового потока, чтобы он не использовался также из другого потока. В частности, если фоновый поток считывает данные из базы данных и обновляет объект Customer, а объект Customer связан с узлами графической сцены (такими как элементы пользовательского интерфейса), то может произойти нарушение правил многопоточности! Для таких случаев изменяйте объект Customer из потока FX приложения, а не из фонового потока.

     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 и другие элементы пользовательского интерфейса и узлы графа сцены используют ObservableList, часто возникает необходимость создать и вернуть ObservableList из задачи. Если вы не хотите отображать промежуточные значения, самый простой способ правильно написать такую задачу — просто создать ObservableList в методе call, а затем вернуть его по завершении задачи.

     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, заполняется и затем возвращается.

Задача, возвращающая частичные результаты

Иногда вы хотите создать задачу, которая будет возвращать частичные результаты. Возможно, вы строите сложный граф сцены и хотите отображать граф сцены по мере его построения. Или, возможно, вы читаете большое количество данных через сеть и хотите отображать записи в 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;
         }
     };
 

Другой способ сделать это — предоставить новое свойство в задаче, которое будет представлять частичный результат. Затем убедитесь, что используете 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();
         }
     }
 

Задача, изменяющая граф сцены

Как правило, задачи не должны взаимодействовать напрямую с пользовательским интерфейсом. Это создает тесную связь между конкретной реализацией задачи и конкретной частью вашего пользовательского интерфейса. Однако, когда вам нужно создать такую связь, вы должны убедиться, что используете 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!");
         }
     };