Dieser Artikel stellt Ihnen die Thread-Pool-Probleme vor, die während des Interviews auftreten können. Er hat einen gewissen Referenzwert.
Wir stoßen bei Interviews oft auf Fragen zu Multithreading und Thread-Pools. Heute lernen wir etwas über den Thread-Pool in Java.
Ein Thread-Pool bezieht sich auf das Erstellen einer Sammlung von Threads während der Initialisierung einer Multithread-Anwendung und die anschließende Wiederverwendung dieser Threads, wenn stattdessen neue Aufgaben ausgeführt werden müssen einen neuen Thread zu erstellen. Die Anzahl der Threads in einem Thread-Pool hängt normalerweise vollständig von der Menge des verfügbaren Speichers und den Anforderungen der Anwendung ab. Es ist jedoch möglich, die Anzahl der verfügbaren Threads zu erhöhen. Jedem Thread im Thread-Pool wird eine Aufgabe zugewiesen. Sobald die Aufgabe abgeschlossen ist, kehrt der Thread zum Pool zurück und wartet auf die nächste zugewiesene Aufgabe.
Um es ganz klar auszudrücken: Es handelt sich um eine Thread-Sammlung , die mehrere Threads für eine Anwendung ausführt.
Mithilfe des Thread-Pools habe ich derzeit das Problem gelöst:
Verwenden Sie den Thread-Pool, um mehrere Cover in einem Video zu erhalten und so zu sparen Geld Es hat einige Zeit und Ressourcen gekostet
Der Hintergrundserver unterstützt das Hochladen mehrerer Bilder nicht, daher verwenden wir den Thread-Pool, um mehrere Bilder hochzuladen, wodurch die Upload-Zeit verkürzt wird
Das Rendering ist wie folgt:
Vor dem Hochladen: Es werden 9 Bilder aufgenommen Mindestens 3 Sekunden, verwenden Sie nach der Optimierung des Thread-Pools 9 Bilder in 1 Sekunde.
Die Verwendung von Threads in Multithread-Anwendungen ist aus folgenden Gründen notwendig:
1. Reduziert die Anzahl der erstellten und zerstörten Threads. Jeder Arbeitsthread kann zur Ausführung mehrerer Aufgaben wiederverwendet werden.
2. Sie können die Anzahl der Arbeitsthreads im Thread-Pool entsprechend der Kapazität des Systems anpassen, um zu verhindern, dass der Server aufgrund übermäßigen Speicherverbrauchs erschöpft wird (jeder Thread benötigt etwa 1 MB). Je mehr Threads geöffnet werden, desto mehr Speicher wird verbraucht und es kommt schließlich zum Absturz.
Thread-Pools verbessern die Antwortzeit einer Anwendung. Da die Threads im Thread-Pool bereit sind und darauf warten, Aufgaben zugewiesen zu werden, kann die Anwendung sie direkt verwenden, ohne einen neuen Thread zu erstellen.
Der Thread-Pool erspart der CLR den Aufwand, für jede kurzlebige Aufgabe einen vollständigen Thread zu erstellen, und kann nach Abschluss der Aufgabe Ressourcen zurückgewinnen.
Der Thread-Pool optimiert Thread-Zeitscheiben basierend auf den Prozessen, die derzeit im System ausgeführt werden.
Der Thread-Pool ermöglicht es uns, mehrere Aufgaben zu starten, ohne Eigenschaften für jeden Thread festzulegen.
Der Thread-Pool ermöglicht es uns, eine Objektreferenz zu übergeben, die Statusinformationen für die Programmparameter der ausgeführten Aufgabe enthält.
Der Thread-Pool kann verwendet werden, um das Problem der Begrenzung der maximalen Anzahl von Threads zur Bearbeitung einer bestimmten Anfrage zu lösen.
Besänftige den alten Fafafa
Die Rolle des Thread-Pools besteht darin, einzuschränken Ausführung im System Die Anzahl der Threads.
Je nach Systemumgebung kann die Anzahl der Threads automatisch oder manuell eingestellt werden, um den besten Betriebseffekt zu erzielen. Weniger verschwendet Systemressourcen und mehr führt zu Systemüberlastung und Ineffizienz. Verwenden Sie den Thread-Pool, um die Anzahl der Threads zu steuern, und andere Threads warten in der Schlange. Nachdem eine Aufgabe ausgeführt wurde, wird die vorderste Aufgabe in der Warteschlange übernommen und die Ausführung beginnt. Wenn sich in der Warteschlange kein Warteprozess befindet, wartet diese Ressource des Thread-Pools. Wenn eine neue Aufgabe ausgeführt werden muss und sich im Thread-Pool wartende Arbeitsthreads befinden, kann sie ausgeführt werden. Andernfalls gelangt sie in die Warteschlange.
Geben Sie mir ein Beispiel
new Thread(new Runnable() {
@Override
public void run() {
paPaPaYourGridFriend();
}
}).start();Wenn Sie immer noch einen neuen Thread verwenden, um eine asynchrone Aufgabe auszuführen, sind Sie raus!
Wenn Sie immer noch einen neuen Thread verwenden, um eine asynchrone Aufgabe auszuführen, sind Sie raus!
Wenn Sie immer noch einen neuen Thread verwenden, um eine asynchrone Aufgabe auszuführen, sind Sie raus!
a Jedes Mal, wenn ein neuer Thread ein Objekt erstellt, ist die Leistung schlecht.
b. Threads verfügen nicht über eine einheitliche Verwaltung, es kann eine unbegrenzte Anzahl neuer Threads geben, sie konkurrieren miteinander und belegen möglicherweise zu viele Systemressourcen, was zu Abstürzen oder OOM führt.
c. Fehlen weiterer Funktionen, wie z. B. geplante Ausführung, periodische Ausführung und Thread-Unterbrechung.
1. newSingleThreadExecutor
Erstellen Sie einen Single-Threaded-Thread-Pool. In diesem Thread-Pool arbeitet nur ein Thread, was einem einzelnen Thread entspricht, der alle Aufgaben seriell ausführt. Wenn der einzige Thread abnormal endet, wird er durch einen neuen Thread ersetzt. Dieser Thread-Pool stellt sicher, dass alle Aufgaben in der Reihenfolge ausgeführt werden, in der sie übermittelt werden.
2.newFixedThreadPool
创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。
3. newCachedThreadPool
创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，
那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。
4.newScheduledThreadPool
创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。
private void TextnewSingleThreadExecutor(){
ExecutorService pool = Executors. newSingleThreadExecutor();
MyTask1 task1 = new MyTask1();
MyTask2 task2 = new MyTask2();
MyTask3 task3 = new MyTask3();
// pool.execute(task1);
// pool.execute(task2);
// pool.execute(task3);
new Thread(task1).start();
new Thread(task2).start();
new Thread(task3).start();
}
private class MyTask1 implements Runnable{
@Override
public void run() {
//循环输出
for(int i = 0; i <h5>ScheduledExecutorService</h5><p><img src="https://segmentfault.com/img/remote/1460000015702768" alt=" " title=" "><br></p><h5>newFixedThreadPool</h5><p><img src="https://segmentfault.com/img/remote/1460000015702769" alt=" " title=" "></p><h5><img src="https://segmentfault.com/img/remote/1460000015702770" alt=" " title=" "></h5><p style="max-width:90%"><strong>newCachedThreadPool</strong></p><p><img src="https://segmentfault.com/img/remote/1460000015702771" alt=" " title=" "><br></p><h6>相比new Thread，Java提供的四种线程池的好处在于：</h6>a. 重用存在的线程，减少对象创建、消亡的开销，性能佳。
b. 可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞。
c. 提供定时执行、定期执行、单线程、并发数控制等功能。
线程池真的是太好用了，如果在项目中通过线程池管理线程，，你将会发现其中的诸多优势！
20+个很棒的Android开源项目
2018年Android面试题含答案--适合中高级（下）一份完整的Android Studio搭建Flutter教程[](http://mp.weixin.qq.com/s?__b...
深入了解JAVA的线程中断方法经验之总结
子线程为什么不能更新UI线程详解
相关推荐：
Das obige ist der detaillierte Inhalt vonFragen zu Thread-Pools, die in PHP-Interviews auftreten können. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
