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

Задачи гибкие и очень полезны для инкапсуляции «работы». Так как 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.

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

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

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

Реагирование на изменения состояния в общем виде

Иногда может потребоваться написать задачу, которая обновляет свой прогресс, сообщение, текст или каким-либо другим образом реагирует всякий раз, когда происходит изменение состояния в задаче. Например, вы можете изменить сообщение состояния задачи при изменении состояния задачи на Failure, Success, Running или Cancelled.

     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!");
         }
     };