Récemment, j'ai appris et étudié l'utilisation du multi-lancement Java lors de l'optimisation du code, puis je l'ai résumé après avoir lu les idées des novices.
1. Hériter de la classe de threads pour implémenter le multi-threading
Bien que la méthode qui hérite de la classe de threads soit répertoriée comme une méthode d'implémentation multi-thread, le thread est essentiellement une instance de l'interface Runnable, qui représente une instance d'un thread, et la seule façon de démarrer un thread est via la méthode d'instance start () de la classe de thread. La méthode start () est une méthode native qui démarrera un nouveau thread et exécutera la méthode run (). Cette méthode est très simple pour implémenter le multi-threading. En étendant directement le thread via votre propre classe et en réécrivant la méthode run (), vous pouvez démarrer un nouveau thread et exécuter la méthode run () que vous définissez. Par exemple:
classe publique Mythread étend Thread {public void run () {System.out.println ("mythread.run ()"); }} Démarrez le fil au bon endroit comme suit:
Mythread mythread1 = new mythread (); Mythread mythread2 = new mythread (); mythread1.start (); mythread2.start ();
2. Implémentez l'interface runnable pour implémenter
Si votre classe étend déjà une autre classe, vous ne pouvez pas étendre directement le thread. Pour le moment, vous devez implémenter une interface exécutable, comme suit:
La classe publique MyThread étend d'autres outils de classe Runnable {public void run () {System.out.println ("mythread.run ()"); }} Afin de démarrer Mythread, vous devez d'abord instancier un fil et passer dans votre propre instance Mythread:
Mythread mythread = new mythread (); Thread thread = nouveau thread (mythread); thread.start ();
En fait, lorsqu'un paramètre cible Runnable est passé au thread, la méthode RUN () du thread appellera Target.Run (), reportez-vous au code source JDK:
public void run () {if (cible! = null) {Target.run (); }} 3. Utilisez ExecutorService, Callable et Future pour réaliser le multi-threads avec des résultats de retour
ExecutorService, callable et futur objets sont en fait des classes fonctionnelles dans le cadre de l'exécuteur. Il s'agit d'une explication très détaillée du cadre. Le thread qui renvoie le résultat est une nouvelle fonctionnalité introduite dans JDK1.5. C'est en effet très pratique. Avec cette fonctionnalité, je n'ai pas besoin de mener beaucoup de problèmes pour obtenir la valeur de retour, et même si elle est implémentée, elle peut être pleine d'échappatoires.
Les tâches qui peuvent renvoyer les valeurs doivent implémenter l'interface appelée et, de même, les tâches qui ne renvoient pas les valeurs doivent avoir l'interface exécutable. Après avoir exécuté la tâche appelable, vous pouvez obtenir un futur objet. Appelez-vous sur l'objet pour remettre l'objet renvoyé par la tâche appelable. Combiné avec le service d'exécution d'interface de pool de threads, vous pouvez réaliser le multi-threading légendaire avec le résultat de retour. Vous trouverez ci-dessous un exemple complet de test multi-thread avec des résultats retournés. Si vous l'avez vérifié sous JDK1.5, vous pouvez l'utiliser directement. Le code est le suivant:
importer java.util.concurrent. *; Importer java.util.date; Importer java.util.list; import java.util.arraylist; / ** * Thread avec valeur de retour * / @SuppressWarnings ("Unchecked") Test de classe publique {public static void main (String [] args) lève ExecutionException, InterruptedException { System.out.println ("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- = Exécuteurs.NewFixEdThreadPool (tasksize); System.out.println (">>>" + f.get (). ToString ()); // obtient les résultats en cours d'exécution de toutes les tâches simultanées pour (Future F: List) {// Obtenez la valeur de retour de la tâche de l'objet futur et la sortie à la console System.out.println (">>>" + f.get (). ToString ()); } Date date2 = new Date (); System.out.println("----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- MyCallable (String TaskNum) {this.taskNum = TaskNum;} Public Object Call () Exception System.out.println (">>>" + TaskNum + "Task Task"); Description du code:
Dans le code ci-dessus, la classe Exécuteurs fournit une série de méthodes d'usine pour la création du pool de threads, et les pools de threads retournés implémentent tous l'interface ExecutorService.
Public Static ExecutorService NewFixEdThreadpool (int nthreads)
Crée un pool de threads avec un nombre fixe de threads.
Public Static ExecutorService NewCachedThreadpool ()
Créer un pool de threads cacheable, l'appel EXECUTE réutilisera les threads précédemment construits (si le thread est disponible). Si le thread existant n'est pas disponible, créez un nouveau thread et ajoutez-le à la piscine. Terminez et supprimez les filetages du cache qui n'ont pas été utilisés depuis 60 secondes.
Public Static ExecutorService NewsingLetHreAdExecutor ()
Créez un exécuteur unique unique.
Public Static ScheduleDExecutorService NewscheduledThreadpool (int corepoolSize)
Créez un pool de threads qui prend en charge l'exécution de tâches chronométrée et périodique, qui peut être utilisée dans la plupart des cas au lieu de la classe de minuterie.
ExecutoReService fournit la méthode soumis (), passant un avenir appelable ou exécutable, et renvoyant. Si le pool de threads d'arrière-plan de l'exécuteur n'a pas terminé le calcul appelé, cet appel renvoie la méthode get () de l'objet futur, qui bloquera jusqu'à ce que le calcul soit terminé.