Java-Thread-Pool-Framework

In diesem Artikel werden hauptsächlich die relevanten Kenntnisse des Java-Thread-Pool-Frameworks vorgestellt. Es hat einen sehr guten Referenzwert, schauen wir es uns mit dem Editor unten an

1. Thread-Pool-Strukturdiagramm

2. Beispiel

Thread-Schnittstelle definieren

public class MyThread extends Thread {
 @Override
 publicvoid run() {
 System.out.println(Thread.currentThread().getName() + "正在执行");
 }
}

1: newSingleThreadExecutor

ExecutorService pool = Executors. newSingleThreadExecutor();
 Thread t1 = new MyThread();
 Thread t2 = new MyThread();
 Thread t3 = new MyThread();
 //将线程放入池中进行执行
 pool.execute(t1);
 pool.execute(t2);
 pool.execute(t3);
 //关闭线程池
 pool.shutdown();

Eingabeergebnis:

pool-1-thread-1正在执行
pool-1-thread-1正在执行
pool-1-thread-1正在执行

2: newFixedThreadPool

ExecutorService pool = Executors.newFixedThreadPool(3);
Thread t1 = new MyThread();
 Thread t2 = new MyThread();
 Thread t3 = new MyThread();
 Thread t4 = new MyThread();
 Thread t5 = new MyThread();
 //将线程放入池中进行执行
 pool.execute(t1);
 pool.execute(t2);
 pool.execute(t3);
 pool.execute(t4);
 pool.execute(t5);
pool.shutdown();

Eingabeergebnis:

pool-1-thread-1正在执行
pool-1-thread-2正在执行
pool-1-thread-1正在执行
pool-1-thread-2正在执行

3 :newCachedThreadPool

ExecutorService pool = Executors.newCachedThreadPool();
 Thread t1 = new MyThread();
 Thread t2 = new MyThread();
 Thread t3 = new MyThread();
 Thread t4 = new MyThread();
 Thread t5 = new MyThread();
 //将线程放入池中进行执行
 pool.execute(t1);
 pool.execute(t2);
 pool.execute(t3);
 pool.execute(t4);
 pool.execute(t5);
 //关闭线程池
 pool.shutdown();

Eingabeergebnis:

pool-1-thread-2正在执行
pool-1-thread-4正在执行
pool-1-thread-3正在执行
pool-1-thread-1正在执行
pool-1-thread-5正在执行

4 :ScheduledThreadPoolExecutor

ScheduledExecutorService pool = Executors.newScheduledThreadPool(2);
pool.scheduleAtFixedRate(new Runnable() {//每隔一段时间就触发异常
  @Override
  public void run() {
   //throw new RuntimeException();
   System.out.println("================");
  }
 }, 1000, 2000, TimeUnit.MILLISECONDS);
pool.scheduleAtFixedRate(new Runnable() {//每隔一段时间打印系统时间，证明两者是互不影响的
  @Override
  public void run() {
   System.out.println("+++++++++++++++++");
  }
 }, 1000, 2000, TimeUnit.MILLISECONDS);

Eingabeergebnis:

================
+++++++++++++++++
+++++++++++++++++
+++++++++++++++++

3. Thread-Pool-Kernparameter

corePoolSize: im Pool Anzahl der Kernthreads

maximumPoolSize: Die maximal zulässige Anzahl von Threads im Pool.

keepAliveTime: Wenn die Anzahl der Threads größer als der Kern ist, ist dies die maximale Zeit, die überschüssige Threads im Leerlauf auf neue Aufgaben warten, bevor sie beendet werden.

Einheit: Die Zeiteinheit des keepAliveTime-Parameters.

workQueue: Warteschlange, in der Aufgaben vor der Ausführung gehalten werden. Diese Warteschlange enthält nur ausführbare Aufgaben, die von der Ausführungsmethode übermittelt werden.

threadFactory: Factory, die vom Executor zum Erstellen neuer Threads verwendet wird.

Handler: Handler, der verwendet wird, wenn die Ausführung aufgrund einer Überschreitung des Thread-Bereichs und der Warteschlangenkapazität blockiert wird.

ThreadPoolExecutor: Die zugrunde liegende Implementierung der Executors-Klasse.

3.1 Aufgabenwarteschlangenmechanismus

SynchonousQueue: Synchrone Warteschlange, die Warteschlange wird direkt zur Ausführung an den Thread übermittelt, ohne sie zu warten , der Thread-Pool ist normalerweise unbegrenzt

LinkedBlockingQueue: Unbegrenzte Warteschlange Wenn die Anzahl der Thread-Pool-Threads die maximale Anzahl erreicht, warten neue Aufgaben in der Warteschlange auf die Ausführung, was dazu führen kann, dass die Warteschlange unendlich erweitert wird

ArrayBlockingQueue: Bounded Queue hilft, die Erschöpfung der Ressourcen zu verhindern. Sobald die Obergrenze erreicht ist, können neue Aufgaben verloren gehen

Hinweis:

Use of newSingleThreadExecutor and newFixedThreadPool is LinkedBlockingQueue

newCachedThreadPool uses SynchonousQueue

newScheduledThreadPool uses DelayedWorkQueue

3.2 Thread execution process

3.3 Thread-Größenbestimmung:

CPU-intensiv: Öffne so wenig Threads wie möglich, die optimale Anzahl Anzahl der Threads ist Ncpu+ 1

io-intensiv: mehrere Threads, 2Ncpu

Gemischt: Je nach Situation kann es in io-intensiv und Cou-intensiv aufgeteilt werden

Weitere Java-Thread-Pools Für Framework-bezogene Artikel beachten Sie bitte die chinesische PHP-Website!