Résumé de la méthode d'implémentation de la lecture multithre en Java

Trois façons d'implémenter le multi-threading en Java

En Java, il existe trois façons d'implémenter le multi-threading. La première méthode: hériter de la classe de thread et remplacer la fonction d'exécution. La deuxième méthode: implémentez l'interface Runnable et réécrivez la fonction d'exécution. La troisième méthode: implémentez l'interface appelée et remplacez la fonction d'appel. Cet article expliquera comment ces trois méthodes peuvent être mises en œuvre par des exemples. Si vous en avez besoin, veuillez y consulter.

(1) Hériter de la classe de thread et remplacer la fonction d'exécution.

 La classe XX étend Thread {public void run () {Thread.Sleep (1000) // Le fil dort pendant 1000 millisecondes, le sommeil fait entrer le thread à entrer dans l'état de bloc et de libérer les ressources}}

Fil de démarrage:

Object.start () // Démarrez le thread, exécutez la fonction d'exécution

(2) implémenter l'interface exécutable, le code est le suivant

 class MyThread implémente Runnable {Private String Name; public mythread (name de chaîne) {super (); this.name = name; } @Override public void run () {for (int i = 0; i <200; i ++) {System.out.println ("thread" + name + "--->" + i); }}} public class threaddemo {public static void main (String [] args) {mythread a = new mythread ("a"); Mythread b = new mythread ("b"); Mythread c = new mythread ("c"); nouveau thread (a) .start (); nouveau thread (b) .start (); nouveau thread (c) .start (); }}

(3) Implémentez l'interface appelée et réécrivez la fonction d'appel

Callable est une interface similaire à Runnable. Les classes qui implémentent l'interface callable et les classes qui implémentent le Runnable sont des tâches qui peuvent être exécutées par d'autres threads.

Il existe plusieurs différences entre appelable et runnable:

1. La méthode spécifiée par callable est Call (), tandis que la méthode spécifiée par Runnable est exécutée ().
   
2. La tâche callable peut renvoyer la valeur une fois qu'elle est exécutée, tandis que la tâche Runnable ne peut pas renvoyer la valeur.
   
3. La méthode Call () peut lancer des exceptions, tandis que la méthode run () ne peut pas lancer des exceptions.
   
4. L'exécution de la tâche appelable peut obtenir un futur objet, et Future représente le résultat de calculs asynchrones. Il fournit une méthode pour vérifier si le calcul est terminé, pour attendre que le calcul soit terminé et pour récupérer les résultats du calcul. Grâce à l'objet futur, vous pouvez comprendre l'état d'exécution de la tâche, annuler l'exécution de la tâche et également obtenir les résultats de l'exécution de la tâche
   

Java Calable Code Exemple:

 class TaskWithResult implémente callable <string> {private int id; Public TaskWithResult (int id) {this.id = id; } @Override public String Call () lève une exception {return "Résultat de taskwithResult" + id; }} public class callableTest {public static void main (String [] args) lève InterruptedException, ExecutionException {exécutorService exec = exécutors.newcachedThreadPool (); ArrayList <futur <string>> Results = new ArrayList <futur <string >> (); // Future est équivalent à un conteneur utilisé pour stocker les résultats de l'exécution de l'exécuteur pour (int i = 0; i <10; i ++) {results.add (exec.submit (new taskwithResult (i))); } pour (futur <string> fs: résultats) {if (fs.isdone ()) {System.out.println (fs.get ()); } else {System.out.println ("Le résultat futur n'est pas encore complet"); }} exec.shutdown (); }}

Merci d'avoir lu, j'espère que cela peut vous aider. Merci pour votre soutien à ce site!