Was sind die Unterschiede zwischen Runnable und Thread in Java?

Es gibt zwei Möglichkeiten, Multithreading in Java zu implementieren: Eine besteht darin, die Thread-Klasse zu erben, und die andere darin, die Runnable-Schnittstelle zu implementieren. Die Thread-Klasse ist im Paket java.lang definiert. Solange eine Klasse die Thread-Klasse erbt und die run()-Methode in dieser Klasse überschreibt, kann sie Multithread-Operationen implementieren. Eine Klasse kann jedoch nur eine übergeordnete Klasse erben, was eine Einschränkung dieser Methode darstellt.

Sehen Sie sich das folgende Beispiel an:

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();  }  }

Allerdings sind die Ergebnisse zu diesem Zeitpunkt sehr regelmäßig. Zuerst wird das erste Objekt ausgeführt, und dann wird das zweite Objekt ausgeführt, und sie laufen nicht miteinander. In der JDK-Dokumentation ist zu finden, dass nach dem Aufruf der start()-Methode die run()-Methode über die JVM gefunden wird. Starten Sie als Nächstes die start()-Methode, um den Thread zu starten:

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();  }  };

Auf diese Weise kann das Programm den interaktiven Vorgang normal abschließen. Warum müssen Sie also die Methode start(); verwenden, um mehrere Threads zu starten?

Im JDK-Installationspfad ist src.zip das gesamte Java-Quellprogramm in Thread. Sie können feststellen, dass in dieser Methode privates void start0() verwendet wird Der native Schlüssel ist Das Wort bedeutet, dass die zugrunde liegenden Funktionen des Betriebssystems aufgerufen werden können. Dann wird diese Technologie zur JNI-Technologie (Java Native Interface). Thread-Klasse, verwendet aber die Runnable-Schnittstelle Finish.

public interface Runnable{  public void run();  }

Beispiel:

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);  }  }  };

Aber es gibt keine start()-Methode in der mit Runnable definierten Unterklasse, sondern nur in der Thread-Klasse. Wenn man die Thread-Klasse zu diesem Zeitpunkt beobachtet, gibt es einen Konstruktor: public Thread (Runnable Targeter). Dieser Konstruktor akzeptiert eine Unterklasseninstanz von Runnable, was bedeutet, dass der von Runnable implementierte Multithread über die Thread-Klasse gestartet werden kann. (start() kann Systemressourcen koordinieren):

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();  }  }

Der Unterschied und die Verbindung zwischen den beiden Implementierungsmethoden:

Bei der Programmentwicklung wird die Implementierung der Runnable-Schnittstelle immer die sein, solange es sich um Multithreading handelt Der wichtigste ist, dass die Vererbung der Thread-Klasse im Vergleich zur Implementierung der Runnable-Schnittstelle die folgenden Vorteile bietet:

Vermeiden Sie die Einschränkungen der Punktvererbung. Eine Klasse kann mehrere Schnittstellen erben.

Geeignet für die gemeinsame Nutzung von Ressourcen
Nehmen Sie als Beispiel das Ticketverkaufsprogramm, das durch die Thread-Klasse abgeschlossen wird:

• 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--);  }  }  }  };

  Das Folgende wird verwendet, um Tickets gleichzeitig über drei Thread-Objekte zu verkaufen:

  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();//没有达到资源共享  }  }

  Wenn Sie Runnable verwenden, können Sie eine Ressourcenfreigabe erreichen. Sehen Sie sich das folgende Beispiel an:

  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();  }  };

  Obwohl das Programm jetzt drei Threads enthält, wurden insgesamt 10 Tickets verkauft, was bedeutet, dass Runnable zur Implementierung von Multithreading verwendet werden muss kann eine gemeinsame Nutzung von Ressourcen erreichen.

  Die Verbindung zwischen der Runnable-Schnittstelle und dem Thread:

  Die öffentliche Klasse Thread erweitert das Objekt, das Runnable implementiert.

  Es wurde festgestellt, dass die Thread-Klasse auch eine Unterklasse der Runnable-Schnittstelle ist.

  Das obige ist der detaillierte Inhalt vonWas sind die Unterschiede zwischen Runnable und Thread in Java?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!