Поиск по сайту:

ThreadPoolExecutor — пример пула потоков Java


Пул потоков Java управляет пулом рабочих потоков. Он содержит очередь, которая удерживает задачи, ожидающие выполнения. Мы можем использовать ThreadPoolExecutor для создания пула потоков в Java. Пул потоков Java управляет коллекцией потоков Runnable. Рабочие потоки выполняют Runnable потоки из очереди. java.util.concurrent.Executors предоставляет методы фабрики и поддержки для интерфейса java.util.concurrent.Executor для создания пула потоков в java. Executors — это служебный класс, который также предоставляет полезные методы для работы с классами ExecutorService, ScheduledExecutorService, ThreadFactory и Callable с помощью различных фабричных методов. Давайте напишем простую программу, чтобы объяснить, как она работает. Во-первых, нам нужен класс Runnable с именем WorkerThread.java.

package com.journaldev.threadpool;

public class WorkerThread implements Runnable {
  
    private String command;
    
    public WorkerThread(String s){
        this.command=s;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+" Start. Command = "+command);
        processCommand();
        System.out.println(Thread.currentThread().getName()+" End.");
    }

    private void processCommand() {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public String toString(){
        return this.command;
    }
}

Пример ExecutorService

Вот тестовый программный класс SimpleThreadPool.java, где мы создаем фиксированный пул потоков из среды Executors.

package com.journaldev.threadpool;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class SimpleThreadPool {

    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 10; i++) {
            Runnable worker = new WorkerThread("" + i);
            executor.execute(worker);
          }
        executor.shutdown();
        while (!executor.isTerminated()) {
        }
        System.out.println("Finished all threads");
    }
}

В приведенной выше программе мы создаем пул фиксированного размера из 5 рабочих потоков. Затем мы отправляем 10 заданий в этот пул, поскольку размер пула равен 5, он начнет работать над 5 заданиями, а другие задания будут в состоянии ожидания, как только одно из заданий будет завершено, другое задание из очереди ожидания будет быть подобранным рабочим потоком и выполненным. Вот вывод вышеуказанной программы.

pool-1-thread-2 Start. Command = 1
pool-1-thread-4 Start. Command = 3
pool-1-thread-1 Start. Command = 0
pool-1-thread-3 Start. Command = 2
pool-1-thread-5 Start. Command = 4
pool-1-thread-4 End.
pool-1-thread-5 End.
pool-1-thread-1 End.
pool-1-thread-3 End.
pool-1-thread-3 Start. Command = 8
pool-1-thread-2 End.
pool-1-thread-2 Start. Command = 9
pool-1-thread-1 Start. Command = 7
pool-1-thread-5 Start. Command = 6
pool-1-thread-4 Start. Command = 5
pool-1-thread-2 End.
pool-1-thread-4 End.
pool-1-thread-3 End.
pool-1-thread-5 End.
pool-1-thread-1 End.
Finished all threads

Вывод подтверждает, что в пуле есть пять потоков с именами от «пул-1-поток-1» до «пул-1-поток-5», и они отвечают за выполнение отправленных задач в пул.

Пример ThreadPoolExecutor

Класс Executors обеспечивает простую реализацию ExecutorService с использованием ThreadPoolExecutor, но ThreadPoolExecutor предоставляет гораздо больше возможностей. Мы можем указать количество потоков, которые будут активны при создании экземпляра ThreadPoolExecutor, и мы можем ограничить размер пула потоков и создать собственную реализацию RejectedExecutionHandler для обработки заданий, которые не помещаются в рабочую очередь. Вот наша собственная реализация интерфейса RejectedExecutionHandler.

package com.journaldev.threadpool;

import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;

public class RejectedExecutionHandlerImpl implements RejectedExecutionHandler {

    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        System.out.println(r.toString() + " is rejected");
    }

}

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

package com.journaldev.threadpool;

import java.util.concurrent.ThreadPoolExecutor;

public class MyMonitorThread implements Runnable
{
    private ThreadPoolExecutor executor;
    private int seconds;
    private boolean run=true;

    public MyMonitorThread(ThreadPoolExecutor executor, int delay)
    {
        this.executor = executor;
        this.seconds=delay;
    }
    public void shutdown(){
        this.run=false;
    }
    @Override
    public void run()
    {
        while(run){
                System.out.println(
                    String.format("[monitor] [%d/%d] Active: %d, Completed: %d, Task: %d, isShutdown: %s, isTerminated: %s",
                        this.executor.getPoolSize(),
                        this.executor.getCorePoolSize(),
                        this.executor.getActiveCount(),
                        this.executor.getCompletedTaskCount(),
                        this.executor.getTaskCount(),
                        this.executor.isShutdown(),
                        this.executor.isTerminated()));
                try {
                    Thread.sleep(seconds*1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
        }
            
    }
}

Вот пример реализации пула потоков с использованием ThreadPoolExecutor.

package com.journaldev.threadpool;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class WorkerPool {

    public static void main(String args[]) throws InterruptedException{
        //RejectedExecutionHandler implementation
        RejectedExecutionHandlerImpl rejectionHandler = new RejectedExecutionHandlerImpl();
        //Get the ThreadFactory implementation to use
        ThreadFactory threadFactory = Executors.defaultThreadFactory();
        //creating the ThreadPoolExecutor
        ThreadPoolExecutor executorPool = new ThreadPoolExecutor(2, 4, 10, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(2), threadFactory, rejectionHandler);
        //start the monitoring thread
        MyMonitorThread monitor = new MyMonitorThread(executorPool, 3);
        Thread monitorThread = new Thread(monitor);
        monitorThread.start();
        //submit work to the thread pool
        for(int i=0; i<10; i++){
            executorPool.execute(new WorkerThread("cmd"+i));
        }
        
        Thread.sleep(30000);
        //shut down the pool
        executorPool.shutdown();
        //shut down the monitor thread
        Thread.sleep(5000);
        monitor.shutdown();
        
    }
}

Обратите внимание, что при инициализации ThreadPoolExecutor мы сохраняем начальный размер пула равным 2, максимальный размер пула равен 4, а размер рабочей очереди равен 2. Таким образом, если есть 4 запущенных задачи и отправлено больше задач, рабочая очередь будет содержать только 2 из них. а остальные будут обработаны RejectedExecutionHandlerImpl. Вот вывод вышеуказанной программы, подтверждающий приведенное выше утверждение.

pool-1-thread-1 Start. Command = cmd0
pool-1-thread-4 Start. Command = cmd5
cmd6 is rejected
pool-1-thread-3 Start. Command = cmd4
pool-1-thread-2 Start. Command = cmd1
cmd7 is rejected
cmd8 is rejected
cmd9 is rejected
[monitor] [0/2] Active: 4, Completed: 0, Task: 6, isShutdown: false, isTerminated: false
[monitor] [4/2] Active: 4, Completed: 0, Task: 6, isShutdown: false, isTerminated: false
pool-1-thread-4 End.
pool-1-thread-1 End.
pool-1-thread-2 End.
pool-1-thread-3 End.
pool-1-thread-1 Start. Command = cmd3
pool-1-thread-4 Start. Command = cmd2
[monitor] [4/2] Active: 2, Completed: 4, Task: 6, isShutdown: false, isTerminated: false
[monitor] [4/2] Active: 2, Completed: 4, Task: 6, isShutdown: false, isTerminated: false
pool-1-thread-1 End.
pool-1-thread-4 End.
[monitor] [4/2] Active: 0, Completed: 6, Task: 6, isShutdown: false, isTerminated: false
[monitor] [2/2] Active: 0, Completed: 6, Task: 6, isShutdown: false, isTerminated: false
[monitor] [2/2] Active: 0, Completed: 6, Task: 6, isShutdown: false, isTerminated: false
[monitor] [2/2] Active: 0, Completed: 6, Task: 6, isShutdown: false, isTerminated: false
[monitor] [2/2] Active: 0, Completed: 6, Task: 6, isShutdown: false, isTerminated: false
[monitor] [2/2] Active: 0, Completed: 6, Task: 6, isShutdown: false, isTerminated: false
[monitor] [0/2] Active: 0, Completed: 6, Task: 6, isShutdown: true, isTerminated: true
[monitor] [0/2] Active: 0, Completed: 6, Task: 6, isShutdown: true, isTerminated: true

Обратите внимание на изменение количества активных, завершенных и общих завершенных задач исполнителя. Мы можем вызвать метод shutdown(), чтобы завершить выполнение всех отправленных задач и завершить пул потоков. Если вы хотите запланировать выполнение задачи с задержкой или периодически, вы можете использовать класс ScheduledThreadPoolExecutor. Узнайте больше о них в Java Schedule Thread Pool Executor.