Интерфейс Executor и ExecutorService. Пул потоков

Интерфейс ExecutorService

Интерфейс ExecutorService - это интерфейс, который расширяет интерфейс Executor и предоставляет дополнительные функции для управления выполнением задач и получения результатов их выполнения.

Java-код. Интерфейс ExecutorService

public interface ExecutorService extends Executor {
	void shutdown();
    List shutdownNow();
    boolean isTerminated();
    <T> Future<T> submit(Callable<T> task);
    Future<?> submit(Runnable task);
    . . .
}

ExecutorService позволяет:

• Управлять выполнением задач, включая запуск, остановку и завершение задач.
• Получать результаты задач, а также обрабатывать их результаты или ошибки.
• Контролировать пул потоков, который может быть настроен для определённых потребностей приложения.

Некоторые методы ExecutorService:

• submit(Callable<T> task). Подает задачу на выполнение и возвращает Future, который предоставляет доступ к результату выполнения задачи и позволяет управлять её состоянием.
• submit(Runnable task). Подает задачу на выполнение и возвращает Future, который связан с переданной задачей, но не возвращает результат.
• shutdown(). Завершает выполнение задач, но даёт возможность уже поставленным задачам завершить выполнение. 
• shutdownNow(). Пытается прервать выполнение всех активных задач и возвратить список ожидающих выполнения задач.

ExecutorService - реализация пула Потоков

Интерфейс ExecutorService является реализацией пула Потоков.

Пул потоков — это набор запущенных автоматически потоков, которые всегда доступны для выполнения задач.  

При запуске приложения пул потоков запускает минимальное количество потоков, которые находятся в состоянии ожидания новых задач. Если активных потоков недостаточно для эффективного выполнения задач в пуле, он запускает новые и использует их по принципу повторного использования. 

В Java есть встроенный пул потоков — Java ExecutorService, поэтому использовать его можно без необходимости реализовывать самостоятельно.

Пул потоков похож на группу потоков (класс ThreadGroup), но немного другой смысл.
Пул потоков - это набор запущенных автоматически потоков.
Потоки созданы, запущены и они работают всегда.

Создание пула потоков - Класс Executors

Для создания пула потоков в Java можно использовать один из четырёх методов в классе Executors:

• newSingleThreadExecutor(). Создаёт пул из одного потока, одновременно будет выполняться только одна задача.
• newFixedThreadPool(). Позволяет создать пул с фиксированным количеством потоков.
• newCachedThreadPool(). Создаёт пул, который создаёт новые потоки по запросу и разрушает потоки, которые простаивают больше минуты, если запрос отсутствует.
• newScheduledThreadPool(). Создаёт пул потоков, который может планировать выполнение задач после заданной задержки или через регулярные промежутки времени.

Java-код. Пример 1

public class Executor_1 {

    ExecutorService threadPool = Executors.newFixedThreadPool(4);
    
    // Executors.newFixedThreadPool(4) - создаёт в Java поток с фиксированным количеством потоков. 
    // Метод newFixedThreadPool() принимает один параметр — количество потоков в пуле (в данном случае 4)

}

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

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

Метод execute() - выполнение задач в пуле потоков

Метод execute() - подходит для выполнения задач, не требующих отслеживания результата. Он работает с объектами Runnable.

Метод execute() связан с интерфейсом Executor, который используется для выполнения задач в пуле потоков.

Этот метод запускает задачу, заданную объектом Runnable. Не нужно знать о деталях потока, связанного с задачей. Достаточно создать задачу и передать её методу execute() соответствующего исполнителя.

Java-код. Пример 2.1

public class Executor1 {

    public static void main(String[] args) throws InterruptedException {
        ExecutorService threadPool = Executors.newFixedThreadPool(4);   // ПУЛ ПОТОКОВ

        Task1 task1 = new Task1();			// Объекты Runnable
        Task2 task2 = new Task2();
											// Метод execute() запускает задачу, заданную объектом Runnable
        threadPool.execute(task1);          // Запуск выполнения задачи task1 в threadPool.
        threadPool.execute(task2);
        threadPool.execute(task1);
        threadPool.execute(task2);

        threadPool.shutdown();              // Остановить все потоки исполнения
    }

}

class Task1 implements Runnable {       // Задача №1
    @Override
    public void run() {
        System.out.println("Привет: " + Thread.currentThread().getName());
    }
}

class Task2 implements Runnable {       // Задача №2
    @Override
    public void run() {
        System.out.println("Hello: " + Thread.currentThread().getName());
    }
}

Результат в консоли

Hello: pool-1-thread-2
Hello: pool-1-thread-4
Привет: pool-1-thread-1
Привет: pool-1-thread-3

Метод Shutdown() - позволяет останавливать все потоки исполнения, находящиеся под управлением экземпляра ExecutorService. После вызова этого метода ExecutorService больше не принимает новые задания, а все задания, которые раннее были переданы в ExecutorService, продолжат своё выполнение.

Создание объекта Runnable с использованием анонимного класса

Здесь задача создается иначе: объект Runnable создается с использованием анонимного класса. 

Java-код. Пример 2.2

public class Executor2 {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService threadPool = Executors.newFixedThreadPool(4);   // ПУЛ ПОТОКОВ

        Runnable r1 = new Runnable() {      // создание объекта Runnable и переопределение run()
            @Override
            public void run() {
                System.out.println("Runnable №1: " + Thread.currentThread().getName());
            }
        };

        Runnable r2 = () -> {               // Использование лямбда-выражения
            for (int i = 0; i < 5; i++) {
                System.out.println("Runnable №2: " + Thread.currentThread().getName());
            }
        };

        Task task = new Task();

        threadPool.execute(task);          // Запуск выполнения задачи task в threadPool.
        threadPool.execute(task);
        threadPool.execute(r1);            // Запуск выполнения задач r1 и r2
        threadPool.execute(r2);

        threadPool.shutdown();              // Остановить все потоки исполнения
    }
}

class Task implements Runnable {       // Задача
    @Override
    public void run() {
        System.out.println("Привет: " + Thread.currentThread().getName());
    }
}

Результат в консоли

Привет: pool-1-thread-2
Привет: pool-1-thread-1
Runnable №2: pool-1-thread-4
Runnable №2: pool-1-thread-4
Runnable №2: pool-1-thread-4
Runnable №2: pool-1-thread-4
Runnable №2: pool-1-thread-4
Runnable №1: pool-1-thread-3

Интерфейс Callable в пуле потоков Java позволяет потокам возвращать результаты своей работы. Он похож на интерфейс Runnable, но может вернуть результат в виде объекта Object и способен бросать исключения. Об этом на следующей странице.