Quatre façons d'implémenter le multithreading en Java

Cet article vous apporte des connaissances pertinentes sur java, qui résout principalement les problèmes liés aux quatre façons d'implémenter le multi-threading, y compris l'héritage de la classe Thread, l'implémentation de l'interface Callable pour créer des threads Thread via le wrapper FutureTask et l'utilisation ExecutorService, Callable et Future implémentent le multithreading qui renvoie des résultats, etc. Examinons-les ensemble, j'espère que cela sera utile à tout le monde.

Re apprentissage recommandé: "Java Video Tutorial"

java Il y a quatre façons principales d'implémenter le multi-threading:

Hériter la classe de threads et implémenter l'interface exécutable
implémenter le Interface appelable via le wrapper FutureTask pour créer un thread de thread
Utilisez ExecutorService, Callable
Future pour implémenter le multi-threading avec des résultats de retour
Les deux premières méthodes n'ont aucune valeur de retour une fois le thread exécuté, et le les deux derniers ont une valeur de retour.

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

1. Hériter de la classe Thread pour créer des threads

La classe Thread est essentiellement une instance qui implémente l'interface Runnable et représente une instance d'un thread. La seule façon de démarrer un thread consiste à utiliser la méthode d’instance start() de la classe Thread. La méthode start() est une méthode native qui démarrera un nouveau thread et exécutera la méthode run(). 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 pour créer des threads Thread 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;
    }

}</v></v></v>

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();   //至此，一个线程就创建完成了。</integer></integer></integer></v></v></integer></integer></v></v>

4. et Future pour implémenter des threads qui renvoient des résultats

ExecutorService, Les trois interfaces Callable et Future appartiennent en fait au framework Executor. Le thread qui renvoie le résultat est une nouvelle fonctionnalité introduite dans JDK1.5. Avec cette fonctionnalité, vous n'avez plus besoin de vous donner beaucoup de mal pour 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.

Ce qui suit fournit un exemple de test multithread complet avec les résultats renvoyés. Il a été vérifié sous JDK1.5 et peut être utilisé directement sans aucun problème. 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 >>" + 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 + "毫秒】";  
}  
}</object></future></future>

1 Quelle est la différence entre Runnable et Callable ?

·

La principale différence est que la méthode run 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 l'interface générique Runnable ; ne lance que des exceptions d'exécution et ne peut pas les intercepter et les gérer ;

·

La méthode d'appel d'interface appelable permet de lancer des exceptions et d'obtenir des informations sur les exceptions

2. Comment démarrer un nouveau thread et quelle est la différence entre appeler les méthodes start et run ?

·

L'objet thread appelle la méthode run sans démarrer 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. est juste une méthode courante de thread, ou exécutée dans le thread principal.

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

·

Thread wait (wait) Le thread qui appelle cette méthode entre dans l'état d'attente et n'attend que la notification de un autre thread ou est interrompu sera renvoyé. 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. Différent de la méthode d'attente, sleep ne libérera pas le verrou actuellement occupé, sleep(long) fera entrer le thread dans l'état TIMED-WATING, tandis que sleep(long) fera passer le thread dans l'état TIMED-WATING. la méthode wait() fera entrer le thread actuel dans l'état WATING.

· Le rendement du thread (yield) fera en sorte que le thread actuel cède la tranche de temps d'exécution du processeur et entrera à nouveau en compétition avec d'autres threads pour la tranche de temps du processeur. 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 d'interrompre un thread est de donner au thread un signal de notification, qui affectera un indicateur d'interruption à l'intérieur du thread. Le thread lui-même ne changera pas d'état (comme le blocage, la résiliation, etc.) à cause de cela

· Join attend que d'autres threads terminent la méthode join(), attend que les autres threads se terminent et appelle la jointure () d'un thread dans le thread actuel. Ensuite, le thread actuel passe à l'état de blocage et revient à un autre thread pour se terminer. Le thread actuel passe de l'état de blocage à l'état prêt, en attendant la faveur du CPU

.

· Thread wake-up (notify) méthode notify() dans la classe Object, réveille un seul thread en attente sur le moniteur de cet objet. Si tous les threads attendent sur cet objet, l'un des threads sera choisi pour se réveiller. Le choix est arbitraire et se produit lorsqu'une décision est prise concernant l'implémentation. Le thread le fait en appelant l'une des méthodes wait() attend sur le moniteur de l'objet jusqu'à ce que le thread actuel abandonne le verrou sur cet objet avant le thread réveillé. peut continuer à s'exécuter. Le thread réveillé se synchronisera avec tous les autres threads activement synchronisés sur l'objet de la manière normale. Une méthode similaire est notifyAll(), qui réveille à nouveau tous les threads en attente sur le moniteur.

5. Quelle est la différence entre wait() et sleep() ?

· ① Depuis différentes classes wait() : depuis la classe Object ; sleep() : depuis la classe Thread

· ② Concernant la libération du verrou : wait() : 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 les blocs de code synchronisés sleep() : peut être utilisé n'importe où ;

· ④ Avez-vous besoin d'attraper des exceptions ? wait() : Pas besoin d'attraper des exceptions ; sleep() : Besoin d'attraper des exceptions ?

Principe du multi-threading :

Le multithreading se fait de manière simultanée

. 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. Par conséquent, l'utilisation raisonnable du multithreading peut améliorer l'efficacité, mais une utilisation intensive ne nous apporte pas une amélioration de l'efficacité.

La technologie multi-thread résout principalement le problème de l'exécution de plusieurs threads dans 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.

Apprentissage recommandé : "Tutoriel vidéo Java

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!