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();//但實(shí)際只有10張票，每個線程都賣自己的票??mt3.start();//沒有達(dá)到資源共享??}??}

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();//個實(shí)例化對象mt，就會出現(xiàn)異常??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!