Heim  >  Artikel  >  Java  >  Vier Möglichkeiten zum Erstellen eines Thread-Pools in Java

Vier Möglichkeiten zum Erstellen eines Thread-Pools in Java

Guanhui
GuanhuiOriginal
2020-06-04 09:29:325022Durchsuche

Vier Möglichkeiten zum Erstellen eines Thread-Pools in Java

Vier Möglichkeiten, einen Thread-Pool in Java zu erstellen

1. newCachedThreadPool erstellt einen zwischenspeicherbaren Thread-Pool, wenn die Länge des Thread-Pools den Verarbeitungsbedarf überschreitet , Inaktive Threads können flexibel recycelt werden. Wenn keine Threads recycelt werden können, werden neue Threads erstellt.

2. newFixedThreadPool erstellt einen Thread-Pool mit fester Länge, der die maximale Anzahl gleichzeitiger Threads steuern kann, die in der Warteschlange warten.

3. newScheduledThreadPool erstellt einen Thread-Pool fester Länge, um die geplante und periodische Aufgabenausführung zu unterstützen.

4. newSingleThreadExecutor erstellt einen Single-Threaded-Thread-Pool. Er verwendet nur den einzigen Arbeitsthread, um Aufgaben auszuführen, und stellt so sicher, dass alle Aufgaben in der angegebenen Reihenfolge ausgeführt werden (FIFO, LIFO, Priorität).

newCachedThreadPool

Erstellen Sie einen zwischenspeicherbaren Thread-Pool. Wenn die Länge des Thread-Pools den Verarbeitungsbedarf übersteigt, können inaktive Threads flexibel recycelt werden Es gibt keine Möglichkeit, es zu recyceln und dann einen neuen Thread zu erstellen.

package cn.qbz.thread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Test111907 {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            final int temp = i;
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "   i=" + temp);
                }
            });
        }
    }
}
    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

newFixedThreadPool

Erstellen Sie einen Thread-Pool mit fester Länge, der die maximale Anzahl gleichzeitiger Threads steuern kann, die in der Warteschlange warten.

package cn.qbz.thread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Test111907 {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 10; i++) {
            final int temp = i;
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "   i=" + temp);
                }
            });
        }
    }
}
    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

newScheduledThreadPool

Erstellen Sie einen Thread-Pool fester Länge, um die geplante und periodische Aufgabenausführung zu unterstützen.

package cn.qbz.thread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class Test111907 {
    public static void main(String[] args) {
        final long begin = System.currentTimeMillis();
        ExecutorService executorService = Executors.newScheduledThreadPool(3);
        for (int i = 0; i < 10; i++) {
            final int temp = i;
            final long time = begin;
            executorService.schedule(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "   i=" + temp + "   time=" + (System.currentTimeMillis() - time));
                }
            }, 5, TimeUnit.SECONDS);
        }
    }
}
    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }
    public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.NANOSECONDS,
              new DelayedWorkQueue());
    }

newSingleThreadExecutor

Erstellt einen Single-Threaded-Thread-Pool, der nur einen eindeutigen Arbeitsthread zum Ausführen von Aufgaben verwendet.

stellt sicher, dass alle Aufgaben ausgeführt werden In der angegebenen Reihenfolge ausführen (FIFO, LIFO, Priorität).

package cn.qbz.thread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class Test111907 {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            final int temp = i;
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "   i=" + temp);
                }
            });
        }
    }
}

Empfohlenes Tutorial:

Java-Tutorial

Das obige ist der detaillierte Inhalt vonVier Möglichkeiten zum Erstellen eines Thread-Pools in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!

Stellungnahme:
Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn
Vorheriger Artikel:Servlet-Lebenszyklus 5 PhasenNächster Artikel:Servlet-Lebenszyklus 5 Phasen