What are the differences between Runnable and Thread in Java?

There are two ways to implement multi-threading in java, one is to inherit the Thread class, and the other is to implement the Runnable interface; the Thread class is defined in the java.lang package. As long as a class inherits the Thread class and overrides the run() method in this class, it can implement multi-threaded operations. However, a class can only inherit one parent class, which is a limitation of this method.

Look at the example below:

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

However, the results are very regular at this time. First the first object is executed, and then the second object is executed, and they do not run with each other. It can be found in the JDK documentation that once the start() method is called, the run() method will be found through the JVM. The following starts the start() method to start the thread:

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

In this way, the program can complete the interactive operation normally. So why do we have to use the start(); method to start multi-threads?

In the JDK installation path, src.zip is the entire java source program. Find the definition of the start() method in Thread through this code. You can find that private native void start0() is used in this method. ;The native keyword indicates that the underlying functions of the operating system can be called, so this technology becomes JNI technology (java Native Interface)

Runnable interface

In actual development A multi-threaded operation rarely uses the Thread class, but is completed through the Runnable interface.

public interface Runnable{  public void run();  }

Example:

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

But there is no start() method in the subclass defined using Runnable, only in the Thread class. Observing the Thread class at this time, there is a constructor: public Thread (Runnable targer). This constructor accepts a subclass instance of Runnable, which means that the multi-threading implemented by Runnable can be started through the Thread class. (start() can coordinate system resources):

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

The difference and connection between the two implementation methods:

In program development, as long as it is multi-threaded, it will always be Mainly implement the Runnable interface, because implementing the Runnable interface has the following benefits compared to inheriting the Thread class:

• Avoid the limitations of point inheritance, and a class can inherit multiple interfaces.

• Suitable for resource sharing

Take the ticket selling program as an example, it is completed through the Thread class:

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

The following is passed Three thread objects, selling tickets at the same time:

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

If you use Runnable, you can realize resource sharing. Here is an example:

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

Although there are three threads in the program, a total of 10 tickets were sold. Ticket, that is to say, using Runnable to implement multi-threading can achieve the purpose of resource sharing.

The connection between the Runnable interface and Thread:

public class Thread extends Object implements Runnable

It is found that the Thread class is also a subclass of the Runnable interface.

The above is the detailed content of What are the differences between Runnable and Thread in Java?. For more information, please follow other related articles on the PHP Chinese website!