Fragen zu Thread-Pools, die in PHP-Interviews auftreten können-PHP-Tutorial-php.cn

Dieser Artikel stellt Ihnen die Thread-Pool-Probleme vor, die während des Interviews auftreten können. Er hat einen gewissen Referenzwert.

Vorwort

Wir stoßen bei Interviews oft auf Fragen zu Multithreading und Thread-Pools. Heute lernen wir etwas über den Thread-Pool in Java.

Was ist ein Thread-Pool?

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.

Warum brauchen wir einen Thread-Pool?

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:

Fragen zu Thread-Pools, die in PHP-Interviews auftreten können

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:

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.

Nachteile von Single Thread

Geben Sie mir ein Beispiel

new Thread(new Runnable() {

@Override
public void run() {
   paPaPaYourGridFriend();
}
}).start();

Nach dem Login kopieren

Sagen Sie wichtige Dinge dreimal! ! !

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!

Die Nachteile sind wie folgt:

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.

Java-Thread-Pool

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

创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。

newSingleThreadExecutor

  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>

Nach dem Login kopieren