Автор оригинала: Pankaj Kumar.
Пул потоков Java управляет пулом рабочих потоков. Он содержит очередь, которая заставляет задачи ждать выполнения. Мы можем использовать ThreadPoolExecutor для создания пула потоков в Java.
Пул потоков Java управляет коллекцией выполняемых потоков. Рабочие потоки выполняют выполняемые потоки из очереди. java.util.concurrent.Исполнители предоставляют заводские и вспомогательные методы для java.util.concurrent.Исполнитель интерфейс для создания пула потоков на java.
Исполнители-это служебный класс, который также предоставляет полезные методы для работы с классами ExecutorService, ScheduledExecutorService, ThreadFactory и вызываемыми классами с помощью различных заводских методов.
Давайте напишем простую программу, чтобы объяснить, как она работает.
Во-первых, нам нужен управляемый класс с именем 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 , где мы создаем фиксированный пул потоков из Платформы исполнителей .
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
Исполнители класс обеспечивают простую реализацию 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(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 .