Quelles sont les différences entre Runnable et Thread en Java ?

Il existe deux façons d'implémenter le multi-threading en Java, l'une consiste à hériter de la classe Thread et l'autre consiste à implémenter l'interface Runnable ; la classe Thread est définie dans le package java.lang. Tant qu'une classe hérite de la classe Thread et remplace la méthode run() dans cette classe, elle peut implémenter des opérations multithread. Cependant, une classe ne peut hériter que d'une seule classe parent, ce qui constitue une limitation de cette méthode.

Regardez l'exemple ci-dessous :

package org.thread.demo;  class MyThread extends Thread{  private String name;  public MyThread(String name) {  super();  this.name = name;  }  public void run(){  for(int i=0;i<10;i++){  System.out.println("线程开始："+this.name+",i="+i);  }  }  }  package org.thread.demo;  public class ThreadDemo01 {  public static void main(String[] args) {  MyThread mt1=new MyThread("线程a");  MyThread mt2=new MyThread("线程b");  mt1.run();  mt2.run();  }  }

Cependant, les résultats sont très réguliers à ce moment-là. D'abord, le premier objet est exécuté, puis le deuxième objet est exécuté, et ils ne courent pas ensemble. On peut trouver dans la documentation du JDK qu'une fois la méthode start() appelée, la méthode run() sera trouvée via la JVM. Commençons la méthode start() pour démarrer le fil :

package org.thread.demo;  public class ThreadDemo01 {  public static void main(String[] args) {  MyThread mt1=new MyThread("线程a");  MyThread mt2=new MyThread("线程b");  mt1.start();  mt2.start();  }  };

De cette façon, le programme peut terminer l'opération interactive normalement. Alors pourquoi devons-nous utiliser la méthode start(); pour démarrer le multi-thread ?

Dans le chemin d'installation du JDK, src.zip est l'intégralité du programme source Java. Trouvez la définition de la méthode start() dans Thread via ce code. Vous pouvez trouver que le private native void start0 est utilisé dans. cette méthode. (); Le mot-clé natif indique que les fonctions sous-jacentes du système d'exploitation peuvent être appelées, cette technologie devient donc la technologie JNI (java Native Interface)

Runnable interface#🎜🎜 #

Dans le développement réel, une opération multithread utilise rarement la classe Thread, mais est réalisée via l'interface Runnable.

public interface Runnable{  public void run();  }

Exemple :

package org.runnable.demo;  class MyThread implements Runnable{  private String name;  public MyThread(String name) {  this.name = name;  }public void run(){  for(int i=0;i<100;i++){  System.out.println("线程开始："+this.name+",i="+i);  }  }  };

Mais il n'y a pas de méthode start() dans la sous-classe définie à l'aide de Runnable, uniquement dans la classe Thread. En observant la classe Thread à ce moment, il existe un constructeur : public Thread (Runnable targer). Ce constructeur accepte une instance de sous-classe de Runnable, ce qui signifie que le multi-thread implémenté par Runnable peut être démarré via la classe Thread. (start() peut coordonner les ressources du système) :

package org.runnable.demo;  import org.runnable.demo.MyThread;  public class ThreadDemo01 {  public static void main(String[] args) {  MyThread mt1=new MyThread("线程a");  MyThread mt2=new MyThread("线程b");  new Thread(mt1).start();  new Thread(mt2).start();  }  }

La différence et la connexion entre les deux méthodes d'implémentation :

Tant que Multi- le threading doit toujours se concentrer sur l'implémentation de l'interface Runnable, car l'implémentation de l'interface Runnable présente les avantages suivants par rapport à l'héritage de la classe Thread :

• Pour éviter les limitations de l'héritage de points, une classe peut hériter de plusieurs interfaces.

• Convient au partage de ressources

Prenons comme exemple le programme de vente de billets, réalisé via la classe Thread : # 🎜🎜#

package org.demo.dff;  class MyThread extends Thread{  private int ticket=10;  public void run(){  for(int i=0;i<20;i++){  if(this.ticket>0){  System.out.println("卖票：ticket"+this.ticket--);  }  }  }  };

Ce qui suit utilise trois objets thread pour vendre des billets en même temps :

package org.demo.dff;  public class ThreadTicket {  public static void main(String[] args) {  MyThread mt1=new MyThread();  MyThread mt2=new MyThread();  MyThread mt3=new MyThread();  mt1.start();//每个线程都各卖了10张，共卖了30张票  mt2.start();//但实际只有10张票，每个线程都卖自己的票  mt3.start();//没有达到资源共享  }  }

Si vous utilisez Runnable, vous pouvez réaliser le partage de ressources. 🎜🎜#

package org.demo.runnable;  class MyThread implements Runnable{  private int ticket=10;  public void run(){  for(int i=0;i<20;i++){  if(this.ticket>0){  System.out.println("卖票：ticket"+this.ticket--);  }  }  }  }  package org.demo.runnable;  public class RunnableTicket {  public static void main(String[] args) {  MyThread mt=new MyThread();  new Thread(mt).start();//同一个mt，但是在Thread中就不可以，如果用同一  new Thread(mt).start();//个实例化对象mt，就会出现异常  new Thread(mt).start();  }  };

Bien qu'il y ait maintenant trois fils de discussion dans le programme, un total de 10 billets ont été vendus, ce qui signifie que l'utilisation de Runnable pour implémenter le multi-threading peut permettre le partage de ressources.

La connexion entre l'interface Runnable et Thread :

public class Thread extends Object implémente Runnable

Découvrez les classes de thread sont également des sous-classes de l'interface Runnable.

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!