Über den Autor: CSDN-Content-Partner, technischer Experte, der bei Null anfängt, um zig Millionen tägliche Aktivitäten in einer APP zu ermöglichen.
Konzentrieren Sie sich auf das Teilen von Originalartikelserien in verschiedenen Bereichen, gut in Java-Backend, mobiler Entwicklung, künstlicher Intelligenz usw. Ich hoffe, Sie werden mich stark unterstützen.
Inhaltsverzeichnis
1. Einleitung
Wir fassen weiterhin die Grundlagen von Java zusammen und lernen sie kennen, indem wir die Vergangenheit Revue passieren lassen und Neues lernen.
In diesem Artikel werden ScheduledThreadPoolExecutor und ThreadPoolExecutor beschrieben.
2. Übersicht
Wir raten davon ab, Executors zum Erstellen von Thread-Pools zu verwenden. Um Thread-Pools besser steuern und verwalten zu können, erstellen Sie Thread-Pools über ThreadPoolExecutor oder ScheduledThreadPoolExecutor. Mit diesen beiden Methoden können Sie die Parameter des Thread-Pools entsprechend den spezifischen Anforderungen festlegen, z. B. die Anzahl der Kernthreads, die maximale Anzahl von Threads, den Warteschlangentyp usw., und die Ablehnungsstrategie an die Situation anpassen, in der die Aufgabe ausgeführt wird kann nicht ausgeführt werden.
2.1 Warum wird die Verwendung von Executoren zum Erstellen von Thread-Pools nicht empfohlen?
newFixedThreadPool (feste Anzahl von Threads)
newSingleThreadExecutor (einzelner Thread)
Das Hauptproblem besteht darin, dass die angesammelte Anforderungsverarbeitungswarteschlange sehr viel Speicher oder sogar OOM verbrauchen kann. Die Anzahl der Threads ist festgelegt und es kann leicht zu einer Anhäufung kommen, wenn zu viele Aufgaben vorhanden sind.
newCachedThreadPool (cachebarer Thread-Pool)
newScheduledThreadPool (Thread-Pool für geplante Ausführung)
Das Hauptproblem besteht darin, dass die maximale Anzahl von Threads Integer.MAX_VALUE ist, wodurch eine sehr große Anzahl von Threads oder sogar OOM erstellt werden kann. Die Anzahl der Threads ist unbegrenzt, es gibt viele Aufgaben und es ist einfach, unbegrenzte Threads zu erstellen.
Drei, verwenden
3.1 ThreadPoolExecutor
public class ThreadPoolDemo {
private static ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
2, // 核心线程数
10, // 最大线程数
10L, // 线程 存活时间
TimeUnit.SECONDS, // 线程存活时间单位
new LinkedBlockingQueue(100));// 缓冲队列
public static void main(String[] args) {
threadPoolExecutor.execute(new Runnable() {
@Override
public void run() {
}
});
}
}
Konstruktionsmethode
public ThreadPoolExecutor(
// 线程池核心线程数
int corePoolSize,
// 线程池最大数
int maximumPoolSize,
// 空闲线程存活时间
long keepAliveTime,
// 时间单位
TimeUnit unit,
// 线程池所使用的缓冲队列
BlockingQueue<Runnable> workQueue,
// 线程池创建线程使用的工厂
ThreadFactory threadFactory,
// 线程池对拒绝任务的处理策略
RejectedExecutionHandler handler)
Die Priorität der Verarbeitungsaufgabe ist der Kern-Thread corePoolSize, die Task-Warteschlange workQueue und die maximale Thread-MaximumPoolSize. Wenn alle drei voll sind, verwenden Sie den Handler, um abgelehnte Aufgaben zu verarbeiten.
3.2 ScheduledThreadPoolExecutor
ScheduledThreadPoolExecutor ist eine neue Funktion, die in Java 8 eingeführt wurde und von ThreadPoolExecutor geerbt wurde.
Sie alle stellen einige grundlegende Thread-Pool-Operationen bereit, z. B. die Methode „execute()“ zum Ausführen von Aufgaben und die Methode „schedule()“ zum Verzögern oder Timing der Ausführung von Aufgaben.
Der Unterschied besteht darin, dass ScheduledThreadPoolExecutor die Ausführung von Aufgaben gemäß dem angegebenen Zeitraum und Zeitintervall planen kann, um den Effekt einer regelmäßigen Ausführung von Aufgaben zu erzielen.
ScheduledThreadPoolExecutor wird verwendet, um Timer zu ersetzen, der leistungsfähiger und flexibler als Timer ist. Timer entspricht einem einzelnen Hintergrundthread, während ScheduledThreadPoolExecutor mehrere entsprechende Anzahlen von Hintergrundthreads im Konstruktor angeben kann.
ScheduledThreadPoolExecutor erstellt intern zwei interne Klassen, ScheduledFutureTask und DelayedWorkQueue, die basierend auf diesen beiden Klassen implementiert werden.
Es gibt zwei Möglichkeiten zum Erstellen:
3.2.1 Vom Konstruktor erstellt
new ScheduledThreadPoolExecutor(int corePoolSize, // 核心线程数
ThreadFactory threadFactory, //主要作用是用来捕获异常和设置线程名称
RejectedExecutionHandler handler) //拒绝策略
ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(1);
executor.execute(...);
executor.shutdown(...);
executor.schedule(...);
executor.scheduleAtFixedRate(...);
executor.scheduleWithFixedDelay(...);
executor.submit(...);
3.2.2 Von Executors erstellte Factory-Methode
方式一：
newSingleThreadScheduledExecutor（） 只有一个工作线程的线程池。如果内部工作线程由于执行周期任务异常而被终止，则会新建一个线程替代它的位置。
方式二：
Executors.newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory)
ScheduledExecutorService service = Executors.newScheduledThreadPool(1);
service.execute(...);
service.shutdown(...);
service.schedule(...);
service.scheduleAtFixedRate(...);
service.scheduleWithFixedDelay(...);
service.submit(...);
Unsere am häufigsten verwendeten Methoden sind wie folgt
/**
创建并执行在给定延迟后启用的一次性操作
* @param command 执行的任务
* @param delay 延迟的时间
* @param unit 延迟的时间单位
*/
schedule(Runnable command, long delay, TimeUnit unit)
周期任务，在第一次执行完之后延迟delay后开始下一次执行，重点是任务执行完后才开始下一次。
如果任务执行过程抛出异常，不会再执行该任务！
/**
定时执行 周期任务，
在initialDelay后开始调度该任务，任务执行完成后，延迟 delay 时间再次执行
* @param command 执行的任务
* @param initialDelay 初始延迟的时间
* @param delay 延迟的时间
* @param unit 延迟的时间单位
*/
scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)
周期任务，第一次执行延期时间为initialDelay，之后每隔period执行一次
如果任务执行过程抛出异常，不会再执行该任务！
/**
按照固定的评率定时执行周期任务，不受任务运行时间影响。
在initialDelay后开始调度该任务，然后 delay 时间后再次执行
如果任务执行的时间比period长的话，会导致该任务延迟执行，不会同时执行
* @param command 执行的任务
* @param initialDelay 初始延迟的时间
* @param period 延迟的时间
* @param unit 延迟的时间单位
*/
scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)
ScheduledThreadPoolExecutor verfügt über zwei Strategien zum Herunterfahren:
- Strategie zum Herunterfahren 1: Wenn die Aufgabenwarteschlange leer ist, rufen Sie die Methode „shutdown()“ auf, um den Thread-Pool zu schließen.
- Shutdown-Strategie 2: Wenn alle Aufgaben im Thread-Pool ausgeführt werden, rufen Sie die Methode „shutdown()“ auf, um den Thread-Pool zu schließen.
Der Unterschied zwischen diesen beiden Herunterfahrstrategien besteht darin, dass, wenn die Aufgabenwarteschlange im Thread-Pool leer ist, durch Aufrufen der Methode „shutdown()“ zum Schließen des Thread-Pools der Thread-Pool sofort geschlossen werden kann, wodurch der Zeitaufwand für das Warten auf den Abschluss der Aufgabe vermieden wird. Wenn alle Aufgaben im Thread-Pool ausgeführt werden, kann der Thread-Pool nicht sofort geschlossen werden, indem die Methode „shutdown()“ aufgerufen wird, um den Thread-Pool zu schließen. Sie müssen warten, bis alle Aufgaben ausgeführt wurden, bevor Sie den Thread-Pool schließen.
Andere sind relativ einfach und werden nicht aufgeführt.
Bei der Verwendung von ScheduledThreadPoolExecutor müssen Sie auf die Ausnahmebehandlung achten . Bei unsachgemäßer Verwendung wird die geplante Aufgabe nicht mehr ausgeführt.
3.2.3 Ähnlichkeiten und Unterschiede zwischen ScheduledThreadPoolExecutor und ThreadPoolExecutor
- ThreadPoolExecutor ist eine allgemeine Thread-Pool-Implementierung zum Ausführen übermittelter Aufgaben. Es bietet nicht die Funktion, Aufgaben regelmäßig zu planen. Der ScheduledThreadPoolExecutor ist eine Unterklasse von ThreadPoolExecutor, die die Funktion des Thread-Pools erweitert und verzögerte und geplante Aufgaben ausführen kann.
- ThreadPoolExecutor ist ein auf der Arbeitswarteschlange basierender Thread-Pool, der die Arbeitswarteschlange zum Speichern der auszuführenden Aufgaben verwendet und diese Aufgaben über die Arbeitsthreads im Thread-Pool ausführt. ScheduledThreadPoolExecutor fügt einen auf ThreadPoolExecutor basierenden Scheduler hinzu, um die Ausführung verzögerter und zeitgesteuerter Aufgaben zu verwalten.
- ThreadPoolExecutor erstellt Threads standardmäßig verzögert , d .
4. Empfohlene Lektüre
Datenstrukturen und Algorithmen
