JAVA-Studiennotizen (Multithreading 2) – Erstellung von Multithreading (2) (Thread-Pool ist sehr wichtig)
Methode 1 hinzugefügt: Implementieren der Callable-Schnittstelle
- Im Vergleich zur Verwendung von Runnable ist Callable leistungsfähiger. Im Vergleich zur run()-Methode kann es einen Rückgabewert haben (der call() überschreibt). Die Methode kann Ausnahmen auslösen und generische Rückgabewerte unterstützen .
- Sie müssen die FutureTask-Klasse verwenden , z. B. die Future-Schnittstelle, um das zurückgegebene Ergebnis zu erhalten.
Zukünftige Schnittstellenbeschreibung:- FutrueTask ist die einzige Implementierungsklasse der Futrue-Schnittstelle
- FutureTask implementiert auch die Schnittstellen Runnable und Future. Es kann von einem Thread als Runnable ausgeführt werden und kann auch als Future verwendet werden, um den Rückgabewert von Callable abzurufen
- Die Future-Schnittstelle (FutureTask) kann die Ausführungsergebnisse bestimmter ausführbarer und aufrufbarer Aufgaben abbrechen, abfragen, ob sie abgeschlossen sind, Ergebnisse abrufen usw.
//1.创建一个实现Callzble的实现类
class NumberThread implements Callable{
//2.重写call方法,将此线程需要执行的操作声明在call()中
@Override
public synchronized Object call() throws Exception {
int sum=0;
for (int i = 0; i <=100 ; i++) {
System.out.println(i);
sum+=i;
}
return sum;
}
}
public class MannyThread {
public static void main(String[] args) {
//3创建CaLLable接口实现类的对象
NumberThread numberThread=new NumberThread();
//4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
FutureTask futureTask=new FutureTask(numberThread);
//5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
Thread thread=new Thread(futureTask);
thread.start();
Object sum= null;
try {
//get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
sum = futureTask.get();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
System.out.println("总和"+sum);
}
}
Methode 2 hinzugefügt: Thread-Pool verwenden (dies wird auch häufig in der Entwicklung verwendet)
Hintergrund : Ressourcen, die häufig erstellt und zerstört werden und eine große Menge an Ressourcen verbrauchen, wie z. B. Threads in gleichzeitigen Situationen, haben einen großen Einfluss auf die Leistung.
Idee : Erstellen Sie im Voraus mehrere Threads, legen Sie sie in den Thread-Pool ab, rufen Sie sie direkt ab, wenn Sie sie verwenden, und legen Sie sie nach der Verwendung wieder in den Pool ab. Dadurch kann eine häufige Erstellung und Zerstörung vermieden und eine Wiederverwendung erreicht werden. Ähnlich wie die öffentlichen Verkehrsmittel im Leben.
Vorteile des Thread-Pools:
- Verbesserte Reaktionsfähigkeit (kürzere Zeit zum Erstellen neuer Threads)
- Reduzieren Sie den Ressourcenverbrauch (Threads im Thread-Pool wiederverwenden, nicht jedes Mal neu erstellen müssen).
- Einfache Thread-Verwaltung
Einige Methoden im Zusammenhang mit dem Thread-Pool:
- corePoolSize: Die Größe des Kernpools
- MaximumPoolSize: maximale Anzahl von Threads
- keepAliveTime: Wenn der Thread keine Aufgaben hat, wird er nach Ablauf der maximalen Zeitspanne beendet
- …
Thread-Pool-bezogene API :
JDK 5.0 bietet Thread-Pool-bezogene APIs: ExecutorService und Executors
ExecutorsService: Die echte Thread-Pool-Schnittstelle. Gemeinsame Unterklasse ThreadPoolExecutor
- voidexecute(Runnable command): Aufgabe/Befehl ausführen, kein Rückgabewert, wird im Allgemeinen zum Ausführen von Runnable verwendet
- Zukünftiges Senden (aufrufbare Aufgabe): Führen Sie die Aufgabe aus, haben Sie einen Rückgabewert und führen Sie im Allgemeinen die aufrufbare Aufgabe aus
- void Shutdown(): Schließt den Verbindungspool
Ausführende: Tool-Klassen, Factory-Klassen für Thread-Pools, die zum Erstellen und Zurückgeben verschiedener Arten von Thread-Pools verwendet werden
- Executors.newCachedThreadPool(): Erstellen Sie einen Thread-Pool, der bei Bedarf neue Threads erstellen kann
- Executors.newFixedThreadPool(n); Erstellen Sie einen Thread-Pool mit einer festen Anzahl wiederverwendbarer Threads
- Executors.newSingleThreadExecutor(): Erstellen Sie einen Thread-Pool mit nur einem Thread
- Executors.newScheduledThreadPool(n): Erstellt einen Thread-Pool, der so geplant werden kann, dass Befehle nach einer bestimmten Verzögerung oder in regelmäßigen Abständen ausgeführt werden.
Die spezifische Verwendung des Thread-Pools:
-
Stellen Sie einen Thread-Pool mit der angegebenen Anzahl von Threads bereit x
ExecutorService service= Executors.newFixedThreadPool(x); -
Um die angegebene Thread-Operation auszuführen, müssen Sie ein Implementierungsklassenobjekt bereitstellen, das die Runnable-Schnittstelle oder die Callable-Schnittstelle implementiert
service.execute(new x);//Anwendbar auf Runnable
service.submit();//Anwendbar auf Callable
Hinweis :
service.getClass()= ThreadPoolExecutor;
ThreadPoolExecutor service1=(ThreadPoolExecutor) service;
Rufen Sie die Thread-Pool-Methode über service1 auf, um Attribute zu ändern; -
Schließen Sie den Thread-Pool
service.shutdown();
Beispiel: Erstellen Sie zwei Threads, die ungerade und gerade Zahlen innerhalb von einhundert zurückgeben
class NumThread implements Runnable{
@Override
public void run() {
for (int i = 0; i <=100; i++) {
if (i%2==0) {
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
}
class NumThread1 implements Runnable{
@Override
public void run() {
for (int i = 0; i <=100; i++) {
if (i%2!=0) {
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
}
public class ManyThread2 {
public static void main(String[] args) {
//1.提供指定线程数量的线程池
ExecutorService service= Executors.newFixedThreadPool(10);
//设置线程池的属性
System.out.println(service.getClass());//返回service的类的类型
ThreadPoolExecutor service1=(ThreadPoolExecutor) service;
service1.setCorePoolSize(15);//现在就可以(通过方法)设置属性了
//2.执行指定的线程操作，需要提供实现Runnable接口或Callable接口的实现类对象
service.execute(new NumThread());//适用于Runnable
service.execute(new NumThread1());//适用于Runnable
//service.submit();//适用于Callable
//3.关闭线程池
service.shutdown();
}
}