Quels sont les moyens d'implémenter le multithreading en Java ?

Avant-propos

Il existe quatre manières principales d'implémenter le multithreading Java :

① Hériter de la classe Thread, implémenter l'interface Runnable

② Implémenter l'interface Callable pour créer des threads Thread via le wrapper FutureTask

③ Utiliser ExecutorService, Callable

④ Implémentation future Multi-threading avec résultats de retour

Les deux premières méthodes n'ont pas de valeur de retour après l'exécution du thread, et les deux dernières méthodes ont des valeurs de retour.

Quatre façons d'implémenter le multi-threading

1. Hériter de la classe Thread pour créer un thread

La classe Thread est essentiellement une instance qui implémente l'interface Runnable, représentant une instance d'un thread. L’utilisation de la méthode d’instance start() de la classe Thread est le seul moyen de démarrer un thread. Un nouveau thread exécutant la méthode run() est démarré en appelant la méthode start(), qui est une méthode native. Il est très simple d'implémenter le multithreading de cette manière. En étendant directement Thread via votre propre classe et en remplaçant la méthode run(), vous pouvez démarrer un nouveau thread et exécuter votre propre méthode run() définie. Par exemple :

public class MyThread extends Thread {  
　　public void run() {  
　　 System.out.println("MyThread.run()");  
　　}  
}  
MyThread myThread1 = new MyThread();  
MyThread myThread2 = new MyThread();  
myThread1.start();  
myThread2.start();

2. Implémentez l'interface Runnable pour créer un thread

Si votre classe a étendu une autre classe, vous ne pouvez pas étendre directement Thread À ce stade, vous pouvez implémenter une interface Runnable, comme suit :

public class MyThread extends OtherClass implements Runnable {  
　　public void run() {  
　　 System.out.println("MyThread.run()");  
　　}  
}

In. Pour démarrer MyThread, vous devez d'abord instancier un Thread et transmettre votre propre instance MyThread :

MyThread myThread = new MyThread();  
Thread thread = new Thread(myThread);  
thread.start();

En fait, lorsqu'un paramètre cible Runnable est passé à Thread, la méthode run() de Thread appellera target.run(), reportez-vous au code source du JDK :

public void run() {  
　　if (target != null) {  
　　 target.run();  
　　}  
}

3. Implémentez l'interface Callable

Créez un fil de discussion via le wrapper FutureTask

L'interface Callable (n'a également qu'une seule méthode) est définie comme suit :

public interface Callable<V>   { 
  V call（） throws Exception;   } 
public class SomeCallable<V> extends OtherClass implements Callable<V> {
    @Override
    public V call() throws Exception {
        // TODO Auto-generated method stub
        return null;
    }
}

Callable<V> oneCallable = new SomeCallable<V>();   
//由Callable<Integer>创建一个FutureTask<Integer>对象：   
FutureTask<V> oneTask = new FutureTask<V>(oneCallable);   
//注释：FutureTask<Integer>是一个包装器，它通过接受Callable<Integer>来创建，它同时实现了Future和Runnable接口。 
  //由FutureTask<Integer>创建一个Thread对象：   
Thread oneThread = new Thread(oneTask);   
oneThread.start();   //至此，一个线程就创建完成了。

4. qui renvoie des résultats

Utilisez ExecutorService, Callable, Future Les threads d'implémentation qui renvoient des résultats

Les interfaces ExecutorService, Callable et Future appartiennent en fait au framework Executor. Dans JDK1.5, les threads qui renvoient des résultats sont introduits en tant que nouvelle fonctionnalité, vous n'avez donc plus besoin de vous soucier d'obtenir la valeur de retour. Et même si vous le mettez en œuvre vous-même, il peut être plein de lacunes.

Les tâches qui peuvent renvoyer des valeurs doivent implémenter l'interface Callable. De même, les tâches qui ne renvoient pas de valeur doivent implémenter l'interface Runnable.

Après avoir exécuté la tâche Callable, vous pouvez obtenir un objet Future. Appelez get sur l'objet pour obtenir l'objet renvoyé par la tâche Callable.

Remarque : la méthode get est bloquante, c'est-à-dire que le thread ne renvoie aucun résultat et la méthode get attendra indéfiniment.

Combiné avec l'interface de pool de threads ExecutorService, vous pouvez réaliser le légendaire multi-threading qui renvoie des résultats.

Il a été vérifié sous JDK1.5 et il n'y a aucun problème. Vous pouvez directement utiliser l'exemple de test multi-thread avec les résultats renvoyés ci-dessous. Le code est le suivant :

import java.util.concurrent.*;  
import java.util.Date;  
import java.util.List;  
import java.util.ArrayList;  
/** 
* 有返回值的线程 
*/  
@SuppressWarnings("unchecked")  
public class Test {  
public static void main(String[] args) throws ExecutionException,  
    InterruptedException {  
   System.out.println("----程序开始运行----");  
   Date date1 = new Date();  
   int taskSize = 5;  
   // 创建一个线程池  
   ExecutorService pool = Executors.newFixedThreadPool(taskSize);  
   // 创建多个有返回值的任务  
   List<Future> list = new ArrayList<Future>();  
   for (int i = 0; i < taskSize; i++) {  
    Callable c = new MyCallable(i + " ");  
    // 执行任务并获取Future对象  
    Future f = pool.submit(c);  
    // System.out.println(">>>" + f.get().toString());  
    list.add(f);  
   }  
   // 关闭线程池  
   pool.shutdown();  
   // 获取所有并发任务的运行结果  
   for (Future f : list) {  
    // 从Future对象上获取任务的返回值，并输出到控制台  
    System.out.println(">>>" + f.get().toString());  
   }  
   Date date2 = new Date();  
   System.out.println("----程序结束运行----，程序运行时间【"  
     + (date2.getTime() - date1.getTime()) + "毫秒】");  
}  
}  
class MyCallable implements Callable<Object> {  
private String taskNum;  
MyCallable(String taskNum) {  
   this.taskNum = taskNum;  
}  
public Object call() throws Exception {  
   System.out.println(">>>" + taskNum + "任务启动");  
   Date dateTmp1 = new Date();  
   Thread.sleep(1000);  
   Date dateTmp2 = new Date();  
   long time = dateTmp2.getTime() - dateTmp1.getTime();  
   System.out.println(">>>" + taskNum + "任务终止");  
   return taskNum + "任务返回运行结果,当前任务时间【" + time + "毫秒】";  
}  
}

2. Connaissances liées au multithreading

1. La différence entre Runnable et Callable

La principale différence est que la méthode d'exécution de l'interface Runnable n'a pas de valeur de retour

La méthode d'appel de l'interface Callable a ; une valeur de retour et prend en charge la méthode d'exécution de l'interface générique Runnable. Elle ne peut lancer que des exceptions d'exécution et ne peut pas les intercepter ;

La méthode d'appel de l'interface Callable permet de lancer des exceptions et vous pouvez obtenir des informations sur les exceptions

2. Comment démarrer un nouveau thread et la différence. entre l'appel des méthodes start et run

Appel d'objet Thread La méthode run ne démarre pas le thread. Seul l'objet appelle des méthodes.

L'objet thread appelle start pour ouvrir le thread et permet au jvm d'appeler la méthode run pour s'exécuter dans le thread ouvert. L'appel de la méthode start peut démarrer le thread et faire entrer le thread dans l'état prêt, et la méthode run est simplement. une méthode normale de thread, ou dans l'implémentation du thread principal.

3. Méthodes de base liées aux threads

Les méthodes de base liées aux threads incluent wait, notify, notifyAll, sleep, join, yield, etc.

Thread wait (wait) Le thread qui appelle cette méthode entre dans l'état d'attente et peut n'attendez que les autres threads. Il ne reviendra que lorsqu'il sera notifié ou interrompu. Il convient de noter qu'après avoir appelé la méthode wait(), le verrou de l'objet sera libéré. Par conséquent, la méthode d'attente est généralement utilisée dans les méthodes synchronisées ou les blocs de code synchronisés.

Thread sleep (sleep) sleep fait dormir le thread actuel Contrairement à la méthode wait, sleep ne libérera pas le verrou actuellement occupé sleep(long) fera entrer le thread dans l'état TIMED-WATING et wait(). La méthode mettra le thread actuel en veille. Entrez dans l'état WATING.

Le rendement du thread (yield) fera que le thread actuel cédera la tranche de temps d'exécution du CPU et entrera à nouveau en compétition avec les autres threads pour la tranche de temps du CPU. De manière générale, les threads ayant une priorité élevée ont plus de chances de rivaliser avec succès pour les tranches de temps CPU, mais cela n'est pas absolu. Certains systèmes d'exploitation ne sont pas sensibles à la priorité des threads.

Interruption de thread (interruption) L'intention initiale de l'interruption d'un thread est de donner au thread un signal de notification, qui affectera un indicateur d'interruption à l'intérieur du thread. Ce thread lui-même ne changera pas d'état (comme le blocage, la terminaison, etc.) pour cette raison. Join attend que les autres threads terminent la méthode join(), attend que les autres threads se terminent et appelle la méthode join() de. un thread dans le thread actuel, puis le thread actuel Transition vers l'état bloquant, retour dans un autre thread pour terminer, le thread actuel passe de l'état bloquant à l'état prêt, en attendant la faveur du CPU.

Réveil du thread (notify) La méthode notify() de la classe Object réveille un seul thread en attente sur ce moniteur d'objet. Si tous les threads attendent sur cet objet, l'un des threads sera choisi pour se réveiller. est arbitraire. et se produit lorsqu'une décision est prise concernant l'implémentation, le thread attend sur le moniteur de l'objet en appelant l'une des méthodes wait(). Le thread réveillé ne peut pas continuer l'exécution jusqu'à ce que le thread actuel abandonne le verrou sur cet objet. sera en concurrence de la manière normale avec tous les autres threads se synchronisant activement sur l'objet. Une autre méthode similaire est notifyAll(), qui réveille tous les threads en attente sur le même moniteur.

4. La différence entre wait() et sleep()

① Vient de différentes classes wait() : vient de la classe Object ; sleep() : vient de la classe Thread

② Concernant la libération des verrous : wait( ) : En attente Le verrou sera libéré pendant le processus d'attente ; sleep() : Le verrou ne sera pas libéré pendant le processus d'attente

③ Champ d'utilisation : wait() : doit être utilisé dans le bloc de code synchronisé sleep() ; : peut être utilisé n'importe où ;

④ S'il faut intercepter les exceptions wait() : Pas besoin d'attraper les exceptions ; sleep() : Besoin d'attraper les exceptions

Principe du multi-threading

Principe du multi-threading ; est effectué de manière concurrente. Pour un processeur, il ne peut exécuter qu'un seul programme à un moment donné, c'est-à-dire qu'il ne peut exécuter qu'un seul processus à la fois. Le processeur basculera continuellement entre ces processus et chaque thread s'exécutera une fois. Étant donné que la vitesse d'exécution du processeur est trop rapide par rapport à notre perception, même si le processeur tourne entre plusieurs processus, nous avons l'impression que plusieurs processus s'exécutent en même temps.

Le CPU basculera entre plusieurs processus. Si nous ouvrons trop de programmes, le temps nécessaire au CPU pour passer à chaque processus deviendra également plus long, et nous aurons également l'impression que la machine fonctionne plus lentement. Bien qu'une utilisation raisonnable du multithread puisse améliorer l'efficacité, une utilisation excessive n'entraîne pas d'amélioration de l'efficacité.

La technologie multi-thread résout principalement le problème de l'exécution de plusieurs threads au sein de l'unité de processeur. Elle peut réduire considérablement le temps d'inactivité de l'unité de processeur et augmenter la capacité de débit de l'unité de processeur.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!