So implementieren Sie die Konstruktionsmethode des Java-Thread-Pools
- nach vorne
- 2023-04-19 15:13:07729Durchsuche
1. Einführung
Um die gleichzeitige Programmierung zu realisieren, wurde das Konzept des Prozesses eingeführt. Ein Prozess entspricht einer Aufgabe des Betriebssystems. Mehrere Prozesse führen Aufgaben gleichzeitig aus, wodurch eine gleichzeitige Programmierung erreicht und eine schnellere Ausführung ermöglicht wird.
Da der Prozess jedoch nicht leichtgewichtig genug ist, können die durch das Erstellen und Zerstören eines Prozesses verbrauchten Ressourcen nicht ignoriert werden. Wenn die Anzahl der Prozesse nicht groß ist, ist dieser Ressourcenverbrauch akzeptabel, wenn Prozesse jedoch häufig erstellt und zerstört werden. Das ist eine Menge Kosten.
Was sollen wir tun?
Um dieses Problem zu lösen, haben die Leute ein leichteres Werkzeug eingeführt – den Thread.
Threads werden auch Lightweight-Prozesse genannt. Seine Erzeugung und Zerstörung verbraucht weniger Ressourcen als Prozesse. Was aber, wenn es eine große Anzahl von Aufgaben gibt und Multithreading häufigem Erstellen und Zerstören nicht standhalten kann? Zu diesem Zeitpunkt kommt der Thread-Pool heraus, um das Problem zu lösen!
2. Was ist der Thread-Pool?
Der Thread-Pool ähnelt dem Java-String-Konstanten-Pool.
Threads verwenden vs. keine Threads verwenden
Wenn Sie einen Thread verwenden, nehmen Sie einfach einen Thread direkt aus dem Pool.
Wenn ein Thread nicht verwendet wird, legen Sie diesen Thread in den Pool
Jeder weiß, wie man ihn findet it Der Arbeitsprozess ist ungefähr so.
Lebenslauf einreichen
SCHRIFTLICHE PRÜFUNG
- # 🎜 🎜 #Interview
- Angebot
- Wenn bestanden, ruft das Unternehmen Sie an, um Sie zu benachrichtigen und Ihnen ein Angebot zu senden
- Fehlgeschlagen, und es ist nur allgemein. Das Unternehmen sagt Ihnen nicht, dass Sie nicht bestanden haben, aber es sagt Ihnen nicht, dass Sie überhaupt nicht bestanden haben. Dies liegt daran, dass das Unternehmen Sie möglicherweise in seinen „Talentreservepool“ aufnimmt.
Die Klasse „ThreadPoolExecutor“ ist eine Reihe von Klassen, die von der Java-Standardbibliothek zur Verwendung von Thread-Pools bereitgestellt werden.ThreadPoolExecutor verfügt über vier Konstruktionsmethoden. Jeder enthält unterschiedliche Parameter und wird in unterschiedlichen Szenarien verwendet.
Wir stellen die Konstruktionsmethode mit den meisten Parametern vor.
ThreadPoolExecutor threadPoolExecutor=new ThreadPoolExecutor ( int corePoolSize, int maximumPoolSize , long keepAliveTime , TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler )
#🎜🎜 #Für Sie verstehen möglicherweise nicht ganz, was die Anzahl der Kernthreads und die maximale Anzahl von Threads bewirken. Hier ist ein Beispiel für einen Mitarbeiter, der zur Arbeit geht.
Die Anzahl der Kernfäden beträgt die offiziellen Mitarbeiter des Unternehmens, sodass sie eine Weile fischen können. Wenn Sie entdeckt werden, werden Sie nicht entlassen. (Entspricht den Threads im Thread-Pool, die auch dann nicht zerstört werden, wenn sie nichts tun)
Die maximale Anzahl von Threads ist die Anzahl der regulären Mitarbeiter + Zeitarbeiter im Unternehmen, aber der Zeitarbeiter Hier werden die Fische nach einer gewissen Zeit rausgeschmissen. (Entspricht der Zerstörung des Threads im Thread-Pool)
3.keepAliveTime beschreibt, wie lange Zeitarbeiter fischen können
4.unit ist eine Zeiteinheit, das heißt The Einheit von keepAliveTime.
5.workQueue-Blockierungswarteschlange organisiert die vom Thread-Pool auszuführenden Aufgaben
6.ThreadFactory-Thread-Erstellungsmethode, verwenden Sie diesen Parameter, um die Erstellungsmethode verschiedener Threads festzulegen # 🎜🎜#
7.RejectedExecutionHandler-Handler-Ablehnungsstrategie. Was sollen wir zu diesem Zeitpunkt tun, wenn die Aufgabenwarteschlange voll ist und eine neue Aufgabe eintrifft? (1): Die neueste Aufgabe wird nicht mehr benötigt (2): Die älteste Aufgabe wird nicht mehr benötigt (3): Warten blockieren# 🎜🎜#(4) Open Swing: Ausnahme auslösen
Da ThreadPoolExecutor komplizierter zu verwenden ist, verfügt es über bis zu 7 Parameter. Die Standardbibliothek stellt Programmierern hierfür eine Reihe zusätzlicher Klassen zur Verfügung. Dies entspricht einer weiteren Kapselungsebene von ThreadPoolExecutor.
1.newFixedThreadPool: Erstellen Sie einen Thread-Pool mit einer festen Anzahl von Threads.
ExecutorService Service1 = Executors.newFixedThreadPool (20);
2.newCachedThreadPool: Erstellt eine variable Anzahl von Thread-Pools 由于ThreadPoolExecutor使用起来比较复杂，最多有7个参数。标准库为此又为程序员们提供了一组其他的类。相当于对ThreadPoolExecutor又进行了一层封装。
1.newFixedThreadPool:创建出一个固定线程数量的线程池。
ExecutorService Service2 = Executors.newCachedThreadPool ();
2.newCachedThreadPool：创建出一个数量可变的线程池
ExecutorService Service3 = Executors.newSingleThreadExecutor ();
3.newSingleThreadExecutor：创建只有一个线程的线程池
ExecutorService Service4 = Executors.newScheduledThreadPool (20);
4.newScheduledThreadPool
模拟实现一个线程池的核心操作： .:将任务加到线程池中--submit。 .:使用Worker类描述一个工作线程，Runnable来描述一个任务。 .:创建一个BlockingQueue阻塞队列组织所有任务。 .:每个Worker要做的事情就是不停的从阻塞队列里获取任务并执行。 .:指定线程池中的线程最大数目，如果超过这个数目就不要再继续创建线程了。3.
newSingleThreadExecutor: Erstellt einen Thread Pool mit nur einem Threadimport java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
/**
* Created with IntelliJ IDEA.
*
* @Description: 模拟实现线程池的使用
*/
public class ThreadDemo0327_2 {
public static void main (String[] args) throws IOException, InterruptedException {
ThreadPoll threadPoll=new ThreadPoll ();
for (int i = 0 ; i <10 ; i++) {
threadPoll.submit (new Runnable () {
@Override
public void run () {
System.out.println ("hello");
}
});
}
}
}
class Worker extends Thread{
public BlockingQueue<Runnable> queue=null;
public Worker(BlockingQueue<Runnable> queue){
this.queue=queue;
}
@Override
public void run () {
//工作线程的具体逻辑
//需要从阻塞队列中取任务.
while (true){
try {
Runnable command=queue.take ();
//通过run来执行具体任务
command.run ();
}catch (InterruptedException e){
e.printStackTrace ();
}
}
}
}
class ThreadPoll{
//包含一个阻塞队列，用来组织任务
public BlockingQueue<Runnable> queue=new LinkedBlockingQueue<> ();
//这个list就用来存放当前的工作线程.
public List<Thread> works=new ArrayList<> ();
public int MAX_WORKER_COUNT=10;
//通过这个方法，把任务加入到线程池中
//submit不光可以把任务放到阻塞队列中，也可以负责创建线程
public void submit(Runnable command) throws IOException, InterruptedException {
if(works.size ()<MAX_WORKER_COUNT){
//如果当前工作线程的数量不足线程数目上线，就创建出新的线程
//工作线程就专门找一个类完成
//worker内部要哦能够取到队列的内容，就要把这个队列实例通过worker的构造方法传过去
Worker worker=new Worker (queue);
worker.start ();
works.add (worker);
}
queue.put (command);
}
}
4.newScheduledThreadPool: Erstellen Sie einen Thread-Pool, der die Verzögerungszeit festlegen kann. rrreee4. Simulieren Sie die Implementierung eines Thread-Poolsrrreee
#🎜🎜#Code-Implementierung: #🎜🎜##🎜🎜#我们创建一个线程池并让它不停的创建进程打印hello
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
/**
* Created with IntelliJ IDEA.
*
* @Description: 模拟实现线程池的使用
*/
public class ThreadDemo0327_2 {
public static void main (String[] args) throws IOException, InterruptedException {
ThreadPoll threadPoll=new ThreadPoll ();
for (int i = 0 ; i <10 ; i++) {
threadPoll.submit (new Runnable () {
@Override
public void run () {
System.out.println ("hello");
}
});
}
}
}
class Worker extends Thread{
public BlockingQueue<Runnable> queue=null;
public Worker(BlockingQueue<Runnable> queue){
this.queue=queue;
}
@Override
public void run () {
//工作线程的具体逻辑
//需要从阻塞队列中取任务.
while (true){
try {
Runnable command=queue.take ();
//通过run来执行具体任务
command.run ();
}catch (InterruptedException e){
e.printStackTrace ();
}
}
}
}
class ThreadPoll{
//包含一个阻塞队列，用来组织任务
public BlockingQueue<Runnable> queue=new LinkedBlockingQueue<> ();
//这个list就用来存放当前的工作线程.
public List<Thread> works=new ArrayList<> ();
public int MAX_WORKER_COUNT=10;
//通过这个方法，把任务加入到线程池中
//submit不光可以把任务放到阻塞队列中，也可以负责创建线程
public void submit(Runnable command) throws IOException, InterruptedException {
if(works.size ()<MAX_WORKER_COUNT){
//如果当前工作线程的数量不足线程数目上线，就创建出新的线程
//工作线程就专门找一个类完成
//worker内部要哦能够取到队列的内容，就要把这个队列实例通过worker的构造方法传过去
Worker worker=new Worker (queue);
worker.start ();
works.add (worker);
}
queue.put (command);
}
}运行效果：
可以看到，打印了10个hello。
Das obige ist der detaillierte Inhalt vonSo implementieren Sie die Konstruktionsmethode des Java-Thread-Pools. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!