Класс Task<V>

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

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

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

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

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

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

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

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

В Java нет надежного способа "убить" поток в процессе. Однако, когда cancel вызывается на Task, важно, чтобы Task прекратил обработку. "Незавершающаяся" задача может продолжить обработку и обновление свойств сообщения, текста и прогресса даже после того, как Task был отменен! В Java отмена Task — это совместная работа. Пользователь Task запросит его отмену, а автор Task должен проверить, был ли он отменен внутри тела метода call. Это можно сделать двумя способами. Во-первых, автор Task может проверить метод isCancelled(), унаследованный от FutureTask, чтобы увидеть, был ли Task отменен. Во-вторых, если реализация Task использует какие-либо блокирующие вызовы (например, прерывимые каналы NIO или 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 всегда проверяет отмену.

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

Аналогично предыдущему примеру, только в этот раз мы изменим прогресс задачи на каждой итерации. Обратите внимание, что у нас есть выбор в случае отмены. Хотим ли мы установить прогресс обратно в -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 может произойти в результате отмены 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 я проверю, была ли задача отменена, и если да, то обновим сообщение соответствующим образом и выйдем из цикла.

Задача, которая принимает параметры

Большинство задач требуют некоторых параметров для выполнения полезной работы. Например, задача DeleteRecordTask нуждается в объекте или первичном ключе для удаления из базы данных. Задача ReadFileTask нуждается в URI файла, который нужно прочитать. Поскольку Task работает в фоновом потоке, необходимо позаботиться о том, чтобы тело метода call не считывало или не изменяло общее состояние. Для этого наиболее полезны два метода: использование final переменных и передача переменных Task при создании.

При использовании Task в качестве анонимного класса наиболее естественный способ передачи параметров Task — использование final переменных. В этом примере мы передаем 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 и не работайте с ним из фонового потока. Это может привести к возникновению гонок. В частности, предположим, что у вас есть SaveCustomerTask, который принимает Customer в своем конструкторе. Хотя SaveCustomerTask может иметь final ссылку на 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;
         }
     }
 

Задача, которая не возвращает значение

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