Что такое future java
Concurrent интерфейсы Callable, Future
Интерфейс Callable
Интерфейс Callable очень похож на интерфейс Runnable. Объекты, реализующие данные интерфейсы, исполняются другим потоком. Однако, в отличие от Runnable, интерфейс Callable использует Generic’и для определения типа возвращаемого объекта. Runnable содержит метод run(), описывающий действие потока во время выполнения, а Callable – метод call().
С документацией интерфейса Callable можно познакомиться здесь.
Интерфейс Future
Интерфейс Future также, как и интерфейс Callable, использует Generic’и. Методы интерфейса можно использовать для проверки завершения работы потока, ожидания завершения и получения результата. Результат выполнения может быть получен методом get, если поток завершил работу. Прервать выполнения задачи можно методом cancel. Дополнительные методы позволяют определить завершение задачи : нормальное или прерванное. Если задача завершена, то прервать ее уже невозможно.
Методы интерфейса Future
| Метод | Описание |
|---|---|
| cancel (boolean mayInterruptIfRunning) | попытка завершения задачи |
| V get() | ожидание (при необходимости) завершения задачи, после чего можно будет получить результат |
| V get(long timeout, TimeUnit unit) | ожидание (при необходимости) завершения задачи в течение определенного времени, после чего можно будет получить результат |
| isCancelled() | вернет true, если выполнение задачи будет прервано прежде завершения |
| isDone() | вернет true, если задача завершена |
С документацией интерфейса Future можно познакомиться здесь.
Пример использования интерфейсов Callable, Future
Рассмотрим простейший пример использования интерфейсов Callable и Future. Основная идея данного примера – показать, как можно, используя Future, узнать статус Callable потока и получить возвращенный объект. В примере используется объект executor типа ExecutorService, формирующий пул из трех потоков. Метод submit с параметром Callable возвращает объект Future для каждого из стартуемого потоков.
Класс CallableClass, реализующий интерфейс Callable, использует объект String в качестве generic’a. Соответственно и каждый объект Future также должен использовать тип объекта String.
Результат выполнения
Перед остановкой пула потоков в консоль выводятся наименования потока. Т.е. в примере демонстрируется возможность не прямого обращения к методу call класса, реализующего интерфейс Callable, а косвенно через объект Future, полученного при старте потока.
Что такое future java
Sample Usage (Note that the following classes are all made-up.)
The FutureTask class is an implementation of Future that implements Runnable, and so may be executed by an Executor. For example, the above construction with submit could be replaced by:
Memory consistency effects: Actions taken by the asynchronous computation happen-before actions following the corresponding Future.get() in another thread.
Method Summary
| Modifier and Type | Method and Description |
|---|---|
| boolean | cancel(boolean mayInterruptIfRunning) |
Method Detail
cancel
After this method returns, subsequent calls to isDone() will always return true. Subsequent calls to isCancelled() will always return true if this method returned true.
isCancelled
isDone
Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2020, Oracle and/or its affiliates. All rights reserved. Use is subject to license terms. Also see the documentation redistribution policy.
Русские Блоги
Интерфейс Java Future, понимание шаблонов будущего
Введение в интерфейс Future:
Интерфейс Future предоставляет методы для определения того, была ли задача выполнена, ожидания выполнения задачи для получения результата, а также для установки периода ожидания для выполнения задачи. Этот метод установки тайм-аута является ключом к достижению тайм-аута выполнения программы Java.
boolean cancel (boolean mayInterruptIfRunning) Отменить выполнение задачи. Параметр указывает, следует ли немедленно прервать выполнение задачи или дождаться ее завершения.
boolean isCancelled () Была ли задача отменена, если задача отменена до того, как она завершится в обычном режиме, она вернет true
boolean isDone () Указывает, была ли задача выполнена. Следует отметить, что если задача завершена нормально, ненормально или отменена, она вернет true.
V get () выбрасывает InterruptedException, ExecutionException Дождитесь окончания выполнения задачи, а затем получите результат типа V. InterruptedException Поток прерван ненормально, исключение выполнения задачи ExecutionException, если задача отменена, будет сгенерировано исключение CancellationException
V get (long timeout, TimeUnit unit) выдает исключение InterruptedException, ExecutionException, TimeoutException Как и функция get выше, у нее есть дополнительный параметр времени ожидания. Параметр timeout указывает период тайм-аута, а uint указывает единицу времени, которая определена в классе перечисления TimeUnit. Если время вычисления истекает, будет выброшено исключение TimeoutException
Вместо прямого создания объекта Future вы также можете использовать метод ExecutorService.submit для получения объекта Future.Метод submit поддерживает как тип интерфейса Callable, так и интерфейс Runnable в качестве параметра, что обеспечивает большую гибкость. Примеры использования следующие:
Что такое будущее: принцип будущего заключается в том, что когда вы подаете заявку на ресурс (вычислительный ресурс или ресурс ввода-вывода), вы немедленно возвращаете дескриптор виртуального ресурса. Когда он фактически используется, виртуальный дескриптор преобразуется в реальный ресурс, что эквивалентно Предварительная выборка.
Псевдокод метода использования Future выглядит следующим образом:
Режим Future имеет смысл только в рамках параллельных вычислений. Когда логическая операция имеет много трудоемких операций, трудоемкая операция может быть разделена на несколько менее затратных по времени подопераций, так что подоперации выполняются параллельно, а логический уровень получает результаты подопераций по очереди. Для настройки нам нужно выполнить логическую операцию, требующую выполнения запроса mysql и однократного чтения файла, если мы используем обычный метод синхронизации:
Примеры использования режима будущего:
Подходящее время для использования режима будущего: на стороне клиента нам часто требуется блокировать результаты. Режим будущего может значительно улучшить скорость ответа. В серверной программе блокирующие операции уменьшают пропускную способность системы, а объем будущих испытаний режима ограничен. Как правило, сервер использует асинхронные обратные вызовы для распараллеливания трудоемких операций, а затем объединяет результаты с помощью обратных вызовов. Виртуальный результат генерируется при построении Future.Если результат используется позже, тем менее вероятно, что он будет заблокирован при get_result, поэтому чем больше интервал от генерации будущего до получения результата, тем выше эффективность будущего режима.
Используется в классе асинхронных операций SafeAsyncTask в android:
Описание и пример FutureTask
Одной из «неприятных» задач многопоточного приложения является определение состояния потока (работает или нет, реагирует на внешние воздействия или нет) и останов потока. Если рассматривать обычный поток Thread, то с ним могут возникнуть такие проблемы. Ведь в Java (JDK 1.5 и выше) нет механизма останова потока. Как известно метод Thread.stop() объявлен как Deprecated поскольку «не потокобезопасен», а безопасная инструкция Thread.interrupt() только сообщает потоку о необходимости остановки. Но если данное сообщение проигнорировано, т.е. разработчик не вставил обработку, то и поток не остановится.
И вот здесь на помощь разработчику приходит пакет Concurrent со своими интерфейсами java.util.concurrent.Callable, java.util.concurrent.Future. Данные интерфейсы (подробно представленные на сайте здесь ), а также их различные реализации позволяют решать задачи «внешнего» управления потоками, т.е. не в методе выполнения потока run() или call(). В данной статье будет рассмотрен класс FutureTask и приведен пример контроля состояния потоков и останова одного потока из другого.
Класс FutureTask
Класс-оболочка FutureTask базируется на конкретной реализации интерфейса Future. Чтобы создать реализацию данного класса необходим объект Callable; после этого можно использовать Java Thread Pool Executor для асинхронной обработки. Таким образом, FutureTask представляет удобный механизм для превращения Callable одновременно в Future и Runnable, реализуя оба интерфейса. Объект класса FutureTask может быть передан на выполнение классу, реализующему интерфейс Executor, либо запущен в отдельном потоке, как класс, реализующий интерфейс Runnable.
Конструкторы класса FutureTask
Класс FutureTask содержит следующие два конструктора :
Методы класса FutureTask
| Метод | Описание |
|---|---|
| V get() | получение результата выполнения потока; вызов метода блокирует дальнейшее выполнения до окончания вычислений |
| V get(long timeout, TimeUnit unit) | получение результата до окончания вычислений или до истечения указанного интервала времени; если в течение указанного времени вычисления не завершились, то вызывается исключение TimeoutException |
| boolean cancel(boolean mayInterrupt) | отмена выполнения задачи; если задача уже стартована и параметр mayInterrupt равен true, то она прерывается, в противном случае, если вычисления еще не начаты, то они и не начнутся. При успешной отмене выполнения задачи метод возвращает значение true |
| boolean isCancelled() | метод возвращает true, если задача была отменена до ее нормального завершения |
| boolean isDone() | метод возвращает true, если выполнение задачи завершено, прервано или если в процессе ее выполнения возникло исключение |
Пример использования FutureTask
Рассмотрим простой пример использования FutureTask, в котором создается пул из 3-х потоков, реализующих интерфейс Callable в виде класса CallableDelay. Основная идея примера связана с проверками выполняемых потоков и отмены выполнения задачи одного из потоков.
Конструктор класса CallableDelay в качестве параметров получает временно́й размер задержки delay и идентификатор потока. В зависимости от значения идентификатора потока в методе call() выполняется соответствующее количество циклов с заданной задержкой, после чего поток завершает работу. Второй поток на первом цикле прерывает выполнение 3-го потока вызовом метода cancel. Метод call потока возвращает текстовый объект String в виде наименования потока.
Метод areTasksDone() проверяет завершение выполнения всех задач/потоков вызовом методов isDone() объектов futureTask. Если выполнение всех потоков завершены, то сервис executor останавливает свою работу методом shutdown().
В конструкторе примера создаются два массива из объектов типа CallableDelay и FutureTask. После этого формируется пул для трех потоков сервиса типа ExecutorService и потоки стартуют методом execute сервиса executor. В цикле выполняются различного рода проверки : завершения работы потока методом isDone(), ожидания завершения потока методом get() с временны́ми параметрами и отмены выполнения потока методом isCancelled().
Результат работы примера
При выполнении задачи информационные сообщения, представленные ниже, выводятся в консоль. Согласно последовательности вывода сообщений можно сказать, что при вызове метода isDone() объекта FutureTask 1-го потока программа перешла в режим ожидания завершения работы потока.
После завершения выполнения 1-го потока программа перешла к проверке 2-го потока методом get() с временно́й задержкой.Так как за предоставленное время поток не смог завершить работу, то был вызван TimeoutException и цикл проверки повторился снова.
Только после завершения работы 2-го потока программа перешла к проверке отмены/завершения 3-го потока. Метод isCancelled() подтвердил, что выполнение потока было прервано. Только после этого метод areTasksDone() подтвердил, что все потоки завершили выполнение и цикл проверок был прерван, сервис executor завершил выполнение методом shutdown().
Именование потоков
Стандартная схема именования потока соответствует формату pool-N-thread-M, где N обозначает последовательный номер пула, а M – порядковый номер потока в пуле. Так наименование pool-1-thread-2 означает второй поток в первом пуле жизненного цикла JVM. Каждый раз, когда создается новый пул, глобальный счетчик N инкрементится.
Интерфейсы Callable и Future в Java
Интерфейс Java Callable(java.util.concurrent.Callable) представляет асинхронную задачу, которая может быть выполнена отдельным потоком. Например, можно передать объект Callable в Java ExecutorService, который затем выполнит его асинхронно. Метод call() вызывается для выполнения асинхронной задачи.
Интерфейс Callable довольно прост. Он содержит единственный метод с именем call().
Если задача выполняется асинхронно, результат обычно передается обратно через Java Future. Это тот случай, когда Callable передается в ExecutorService для одновременного выполнения.
Callable использует Generic для определения типа возвращаемого объекта. Класс Executors предоставляет полезные методы для выполнения Java Callable в пуле потоков. Поскольку вызываемые задачи выполняются параллельно, нам нужно дождаться возвращенного объекта.
Callable задачи возвращают объект java.util.concurrent.Future. Используя объект Java Future, мы можем узнать состояние задачи Callable и получить возвращенный объект. Он предоставляет метод get(), который может ожидать завершения Callable и затем возвращать результат.
Future предоставляет метод cancel() для отмены связанной задачи Callable. Существует версия метода get(), в которой мы можем указать время ожидания результата, поэтому полезно избегать блокировки текущего потока на более длительное время.
Существуют методы isDone() и isCancelled() для определения текущего состояния связанной вызываемой задачи.
Вот простой пример задачи с Callable, которая возвращает имя потока, выполняющего задачу через одну секунду. Мы используем платформу Executor для параллельного выполнения 100 задач и используем Java Future для получения результата представленных задач.
После того, как мы выполним вышеуказанную программу, вы заметите задержку вывода, потому что метод get() ожидает завершения задачи, вызываемой Java. Также обратите внимание, что есть только 10 потоков, выполняющих эти задачи.
Вот фрагмент вывода вышеуказанной программы.
Mon Dec 31 20:40:15 PST 2012::pool-1-thread-1
Mon Dec 31 20:40:16 PST 2012::pool-1-thread-2
Mon Dec 31 20:40:16 PST 2012::pool-1-thread-3
Mon Dec 31 20:40:16 PST 2012::pool-1-thread-4
Mon Dec 31 20:40:16 PST 2012::pool-1-thread-5
Mon Dec 31 20:40:16 PST 2012::pool-1-thread-6
Mon Dec 31 20:40:16 PST 2012::pool-1-thread-7
Mon Dec 31 20:40:16 PST 2012::pool-1-thread-8
Mon Dec 31 20:40:16 PST 2012::pool-1-thread-9
Mon Dec 31 20:40:16 PST 2012::pool-1-thread-10
Mon Dec 31 20:40:16 PST 2012::pool-1-thread-2
.
Что делать, если мы хотим переопределить некоторые методы, например, переопределить метод get() для тайм-аута через некоторое время по умолчанию, а не ждать бесконечно?
В этом случае пригодится класс Java FutureTask, который является базовой реализацией Future.
Callable против Runnable
Callable похож на Runnable в том, что оба они представляют задачу, которая предназначена для одновременного выполнения отдельным потоком.
Callable отличается от Runnable тем, что метод run() не возвращает значение и не может генерировать исключения (только RuntimeExceptions).
Runnable изначально был разработан для длительного параллельного выполнения, например, одновременный запуск сетевого сервера или просмотр каталога на наличие новых файлов. Интерфейс Callable больше предназначен для одноразовых задач, которые возвращают один результат.
Средняя оценка / 5. Количество голосов:
Или поделись статьей
Видим, что вы не нашли ответ на свой вопрос.