创建线程的三种方式和区别（转）

今天面试的时候被问到这个题目，当时确实很懵逼，现在想想从三种方法的实现角度可以推断出来。

第一种创建方式：

继承Thread，并且重写run方法。

[java]  view plain  copy

1. package com.easytopit.thread;  
2.   
3. public class ExtendsThread extends Thread {  
4.   
5.     @Override  
6.     public void run() {  
7.         for(int i = 1;i<=100;i++){  
8.             System.out.println("使用继承Thread的方法====="+i);  
9.         }  
10.     }  
11.   
12.       
13. }  

第二种创建方式（一般用的最多）：

实现Runable接口，并且重写run方法。

[java]  view plain  copy

1. package com.easytopit.thread;  
2.   
3. public class RunableThread implements Runnable {  
4.   
5.     @Override  
6.     public void run() {  
7.         for(int i = 1;i<=100;i++){  
8.             System.out.println("使用实现Runnable方法来创建线程====="+i);  
9.         }  
10.     }  
11.   
12. }  

第三种创建方式：

实现Callable接口，并且重写call方法，通过FutureTask类来创建线程

[java]  view plain  copy

1. package com.easytopit.thread;  
2.   
3. import java.util.concurrent.Callable;  
4.   
5. public class CallableThread implements Callable<Integer> {  
6.   
7.     @Override  
8.     public Integer call() throws Exception {  
9.         for(int i = 1;i<=100;i++){  
10.             System.out.println("实现Callable接口并且实现call方法====="+i);  
11.         }  
12.         return null;  
13.     }  
14.   
15. }  

测试类如下：

[java]  view plain  copy

1. package com.easytopit.thread;  
2.   
3. import java.util.concurrent.Callable;  
4. import java.util.concurrent.FutureTask;  
5.   
6. public class ThreadTest {  
7.   
8.     public static void main(String[] args) {  
9.         //创建线程  
10.         Thread t1 = new ExtendsThread();  
11.           
12.         Runnable run = new RunableThread();  
13.         Thread t2 = new Thread(run);  
14.           
15.         Callable<Integer> call = new CallableThread();  
16.         FutureTask<Integer> ft = new FutureTask<>(call);  
17.         Thread t3 = new Thread(ft);  
18.           
19.         //只有start方法才是启动线程  
20.         t1.start();  
21.         t2.start();  
22.         t3.start();  
23.     }  
24. }  

继承Thread类的，代码编写简单，并且可以使用currentThread()方法来访问当前线程，但是继承该类之后不能继承其它的类。

实现Runable接口，有利于扩展性，实现了该接口之后，还可以实现其它接口或者继承其它的类。

实现Callable接口，编写相对于其它两种比较复杂，但是可以有返回值并且能抛出异常。