Класс Task<V>

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

Задачи гибкие и чрезвычайно полезны для инкапсуляции «работы». Поскольку Service предназначен для выполнения задачи, любые задачи, определенные кодом приложения или библиотеки, могут легко использоваться с сервисом. Аналогично, поскольку Task расширяет FutureTask, очень легко и естественно использовать задачу с 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()) приведет к возникновению исключений во время выполнения. Исключение из этого правила — первоначальная настройка задачи, которую можно безопасно выполнять из любого потока. Однако после инициализации и запуска задачи она может использоваться только из потока FX (за исключением методов, явно отмеченных как подходящие для вызова подклассом из фонового потока).

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

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

Примеры

Следующий набор примеров демонстрирует некоторые из наиболее распространенных способов использования задач.

Простая циклическая операция

Первый пример — это простой цикл, который не делает ничего особенно полезного, но демонстрирует основные аспекты правильного написания задачи. Этот пример просто циклирует и выводит в стандартный вывод на каждой итерации цикла. После завершения он возвращает количество итераций.

     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;
         }
     };
 

Сначала мы определяем тип значения, возвращаемого этой задачей. В данном случае мы хотим вернуть количество итераций, поэтому мы укажем задачу типа Integer, используя дженерики. Затем, в реализации метода call, мы выполняем итерацию от 0 до 100000. На каждой итерации мы проверяем, была ли эта задача отменена. Если это было сделано, то мы прерываем цикл и возвращаем количество итераций. В противном случае сообщение выводится в консоль, счётчик итераций увеличивается, и мы продолжаем цикл.

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

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

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

Как и раньше, внутри цикла мы проверяем, была ли задача отменена. Если она была отменена, мы обновим сообщение задачи, чтобы указать, что она была отменена, а затем прервём цикл, как и прежде. Если задача не была отменена, мы обновим её сообщение, чтобы указать текущую итерацию, а затем обновим прогресс, чтобы указать текущий прогресс.

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

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

Задача, принимающая параметры

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

При использовании задачи в виде анонимного класса наиболее естественный способ передачи параметров задаче — использование конечных переменных. В этом примере мы передаём задаче общее количество итераций, которые она должна выполнить.

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

ПРЕДУПРЕЖДЕНИЕ: Не передавайте изменяемое состояние задаче и не работайте с ним из фонового потока. Это может привести к возникновению гонок. В частности, предположим, что у вас есть SaveCustomerTask, который принимает Customer в своём конструкторе. Хотя SaveCustomerTask может иметь конечную ссылку на Customer, если объект Customer изменяемый, то существует возможность, что как SaveCustomerTask, так и некоторый другой код приложения будут считывать или изменять состояние Customer из разных потоков. Будьте очень внимательны в таких случаях, что, в то время как изменяемый объект, такой как Customer, используется из фонового потока, он не используется также из другого потока. В частности, если фоновый поток считывает данные из базы данных и обновляет объект Customer, а объект Customer связан с узлами схемы сцены (такими как элементы управления UI), то это может нарушить правила потоков! В таких случаях изменяйте объект 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!");
         }
     };