Runnable接口和Thread类



 Java开发中，我们实现多线程，有两种方式， 一种是继承Thread类，一种是实现Runnable接口。但是，我们真的理解Runnable？Runnable和Thread一样吗？都是开启新的线程吗？ 为何明明在子线程使用Handler的post(Runnable)，最终还是在主线程中执行呢？...带着这些疑问，我们来开始今天的博文。本文的例子是基于Android Studio。

1、继承Thread类

1. public class MyThread extends Thread {  
2.   
3.     private String name;  
4.   
5.     public MyThread(String name) {  
6.         this.name = name;  
7.     }  
8.   
9.     @Override  
10.     public void run() {  
11.         System.out.println("MyThread is " + name);  
12.     }  
13. }  

2、启动该线程，运用Thread的start方法

1. public class Test1 {  
2.   
3.     public static void main(String[] args){  
4.         MyThread myThread1=new MyThread("线程1");  
5.         MyThread myThread2=new MyThread("线程2");  
6.         MyThread myThread3=new MyThread("线程3");  
7.   
8.         myThread1.start();  
9.         myThread2.start();  
10.         myThread3.start();  
11.   
12.         System.out.println("myThread1 id ="+myThread1.getId());  
13.         System.out.println("myThread1 id ="+myThread2.getId());  
14.         System.out.println("myThread1 id ="+myThread3.getId());  
15.   
16.   
17.     }  
18.   
19. } 

二、实现runnable接口

 

1. public interface Runnable{    
2. public void run();    
3. }  

因为runnable里边没有start方法，所以需要重新启动， 所以，即使实现了Runnable接口，那也无法启动线程，必须依托其他类。而Thread类，有一个构造方法，参数是Runnable对象，也就是说可以通过Thread类来启动Runnable实现的多线程。

1. public Thread(Runnable target) {  
2.      init(null, target, "Thread-" + nextThreadNum(), 0);  
3.  } 

所以，实现Runnable接口后，需要使用Thread类来启动。

创建一个类MyRunnable，实现Runnable接口，

1. ublic class MyRunnable implements Runnable {  
2.   
3.     private String name;  
4.   
5.     public MyRunnable(String name) {  
6.         this.name = name;  
7.     }  
8.     @Override  
9.     public void run() {  
10.         System.out.println("MyRunnable is " + name);  
11.     }  
12. }  

下面是调用以及启动线程并打印线程的id，启动线程还是调用Thread类的start()方法，

1. public class Test1 {  
2.   
3.     public static void main(String[] args){  
4.   
5.         MyRunnable myRunnable1=new MyRunnable("Runnable1");  
6.         MyRunnable myRunnable2=new MyRunnable("Runnable2");  
7.         MyRunnable myRunnable3=new MyRunnable("Runnable3");  
8.   
9.         Thread myThread1=new Thread(myRunnable1);  
10.         myThread1.start();  
11.         System.out.println("myThread1 id ="+myThread1.getId());  
12.         Thread myThread2=new Thread(myRunnable2);  
13.         myThread2.start();  
14.         System.out.println("myThread1 id ="+myThread2.getId());  
15.         Thread myThread3=new Thread(myRunnable3);  
16.         myThread3.start();  
17.         System.out.println("myThread1 id ="+myThread3.getId());  
18.     }  
19.   
20. }  

小结：通过上面的两个小例子程序，我们可以得知，只是实现Runnable接口，并不能启动或者说实现一个线程。Runnable接口，并不能代表一个线程。Runnable接口和线程是两个不同的概念！

换句话说，一个类，实现Runnable接口，这个类可以做很多事情，不仅仅只被用于线程，也可以用于其他功能！