Es gibt vier Methoden zum Erstellen von Threads auf der Oberfläche in Java, aber tatsächlich kann man sagen, dass es zwei gibt
1. Schreiben Sie über die Thread-Klasse die Ausführungsmethode neu. Nennen Sie es noch einmal.
2. Implementieren Sie die Runable-Schnittstelle, um die Ausführungsmethode über die Thread-Klasse neu zu schreiben. Übergeben Sie das Runable-Objekt an den Konstruktor der Thread-Klasse und rufen Sie dann den Anfang der Thread-Klasse auf.
3. Schreiben Sie über die Thread-Klasse die Ausführungsmethode über die Schnittstellen FutureTask und Callable neu, übergeben Sie das Instanzobjekt an die Konstruktionsmethode der Thread-Klasse und passen Sie dann den Anfang der Thread-Klasse an.
4. Erstellen Sie Threads über ThreadPool. Callbale-Objekte oder Runable-Objekte müssen an den Thread-Pool übermittelt werden, um das Timing der Ausführungslogik zu steuern.
Es ist ersichtlich, dass das Wesentliche darin besteht, mit Thread und Thread-Pool zu spielen. Der folgende Code ist ein praktisches Beispiel:
@Slf4j
public class Thread01 {
public static void main(String[] args) throws Exception{
//普通Thread
Thread t1 = new Thread("t1"){
@Override
public void run() {
log.info("普通new Thread run");
}
};
t1.start();
//实现Runbale接口
Runnable runnable = new Runnable() {
@Override
public void run() {
log.info("实现runable接口 run");
}
};
new Thread(runnable,"t2").start();;
//实现callable接口
FutureTask<Integer> task = new FutureTask<>(new Callable<Integer>() {
@Override
public Integer call() throws Exception {
log.info("实现callable接口 run");
return 100;
}
});
new Thread(task,"t3").start();
log.info("执行结果:{}",task.get());
//线程池方式
ExecutorService executorService = Executors.newSingleThreadExecutor();
executorService.submit(runnable);
FutureTask<String> task1 = new FutureTask<>(new Callable<String>() {
@Override
public String call() throws Exception {
return "这是callable";
}
});
executorService.submit(task1);
log.info("线程池执行结果:{}",task1.get());
}
}abschließend:
Die native Erstellung von Threads durch Thread ist in tatsächlichen Projekten selten, da seine Ausführungslogik nur vom aktuellen Thread verwendet werden kann und eine starke Bindungsbeziehung aufweist. Im Allgemeinen wird Runable zum Implementieren der Aufzeichnungslogik verwendet und dann an Thread übergeben. Dann gibt die Callable-Methode mehr Ausführungsergebnisse zurück als die Runable-Methode. Realcode-Anwendungen können für die Kommunikation zwischen Threads verwendet werden, da möglicherweise Ausführungsergebnisse zwischen mehreren Threads erforderlich sind. Der Zweck des Thread-Pools besteht hauptsächlich darin, den Kontextwechsel zu reduzieren und die Ressourcen flexibler zu gestalten. Die Submit-Methode wird bereitgestellt, sodass Sie sich nicht um die interne Implementierung kümmern müssen, sondern nur die Aufgabe senden müssen. Es wird im Allgemeinen für Aufgaben wie die Verarbeitung großer Dateidaten verwendet.