В Java интерфейсы Callable и Future предоставляют мощные инструменты для параллельного программирования и асинхронного выполнения. Они являются частью пакета java.util.concurrent и предлагают способ решения задач, которые могут выполняться независимо и давать результаты. В этой статье мы рассмотрим различные методы, связанные с Callable и Future, а также примеры кода, которые помогут вам эффективно использовать их возможности.

1. Создание вызываемого объекта:
   Для начала давайте посмотрим, как создать экземпляр вызываемого объекта. Интерфейс Callable — это функциональный интерфейс с единственным методом call(), который возвращает результат. Вот пример:

import java.util.concurrent.Callable;
public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        // Perform some computation and return the result
        return "Hello, Callable!";
    }
}

2. Отправка вызываемого объекта в ExecutorService:
   Чтобы выполнить вызываемый объект, вам понадобится ExecutorService. Он представляет собой структуру асинхронного выполнения. Вот как отправить Callable в ExecutorService и получить объект Future:

import java.util.concurrent.*;
public class Main {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        Callable<String> callable = new MyCallable();
        Future<String> future = executorService.submit(callable);
        // Perform other tasks while the Callable is executed asynchronously
        String result = future.get(); // Blocking call to get the result
        System.out.println(result);
        executorService.shutdown();
    }
}

3. Обработка нескольких вызываемых объектов с помощью ignoreAll():
   Метод invokeAll()позволяет отправлять несколько вызываемых объектов и ждать их завершения. Он возвращает список объектов Future, представляющих результаты. Вот пример:

import java.util.List;
import java.util.concurrent.*;
public class Main {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        List<Callable<String>> callables = List.of(new MyCallable(), new MyCallable(), new MyCallable());
        List<Future<String>> futures = executorService.invokeAll(callables);
        for (Future<String> future : futures) {
            String result = future.get();
            System.out.println(result);
        }
        executorService.shutdown();
    }
}

4. Обработка таймаутов с помощью Future.get():
   Метод get()интерфейса Future позволяет получить результат вызываемого объекта. Вы можете указать продолжительность тайм-аута, чтобы избежать блокировки на неопределенный срок. Вот пример:

import java.util.concurrent.*;
public class Main {
    public static void main(String[] args) throws InterruptedException, ExecutionException, TimeoutException {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        Callable<String> callable = new MyCallable();
        Future<String> future = executorService.submit(callable);
        try {
            String result = future.get(1, TimeUnit.SECONDS); // Timeout after 1 second
            System.out.println(result);
        } catch (TimeoutException e) {
            System.out.println("Task timed out!");
            future.cancel(true); // Cancel the task if it exceeds the timeout
        }
        executorService.shutdown();
    }
}

Callable и Future предоставляют необходимые функции для параллельного и асинхронного программирования на Java. Используя эти интерфейсы, вы можете выполнять задачи независимо, получать результаты, обрабатывать тайм-ауты и эффективно управлять несколькими одновременными операциями. Понимание и эффективное использование Callable и Future может значительно повысить производительность и скорость реагирования ваших приложений Java.

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

Реализуя интерфейсы Callable и Future, вы сможете раскрыть истинный потенциал возможностей параллельного программирования Java.