JDK5.0以後Java多線程的實現方式變成了四種，下面來簡單的列舉一下，若是須要更深刻的瞭解，強烈建議閱讀一下源碼。java
1、繼承Thread類重寫run()方法：多線程
1. 建立一個繼承於Thread類的子類
2. 重寫Thread類的run() --> 將此線程執行的操做聲明在run()中
3. 建立Thread類的子類的對象
4. 經過此對象調用start()
ide
1 // 一、 建立一個繼承於Thread類的子類 2 class Test1 extends Thread { 3 4 // 二、 重寫Thread類的run() 5 @Override 6 public void run() { 7 //Thread.currentThread().getName()：獲取當前線程的名字 8 System.out.println("線程須要執行的代碼" + "->" 9 + Thread.currentThread().getName()); 10 } 11 12 } 13 14 public class ThreadTest1 { 15 public static void main(String[] args) { 16 // 三、 建立Thread類的子類的對象 17 Test1 test1 = new Test1(); 18 19 //多線程固然能夠建立多個對象來開啓多個線程 20 Test1 test2 = new Test1(); 21 22 // 四、經過此對象調用start()方法啓動線程 23 //start()方法的做用：1）啓動當前線程 2）調用當前線程的run()方法 24 test1.start(); 25 test2.start(); 26 } 27 }
順便插一句並非test1先調用了start()方法就必定先比test2先執行，不清楚的小夥伴建議先了解一下多線程的概念，這裏主要是對實現多線程的幾種方式簡單總結，概念再也不贅述。學習
2、實現Runnable接口：spa
1. 建立一個實現Runnable接口的類
2. 實現Runnable中的run()方法
3. 建立實現類的對象
4. 將此對象做爲參數傳遞到Thread類的構造器中，建立Thread類的對象
5. 經過Thread類的對象調用start()
線程
1 //1. 建立一個實現Runnable接口的類 2 class Test2 implements Runnable { 3 // 2. 實現Runnable中的run()方法 4 @Override 5 public void run() { 6 System.out.println("線程須要執行的代碼" + "->" 7 + Thread.currentThread().getName()); 8 } 9 } 10 11 public class ThreadTest2 { 12 public static void main(String[] args) { 13 // 3. 建立實現類的對象 14 Test2 test = new Test2(); 15 // 4. 將此對象做爲參數傳遞到Thread類的構造器中，建立Thread類的對象 16 Thread t1 = new Thread(test); 17 Thread t2 = new Thread(test); 18 // 5. 經過Thread類的對象調用start() 19 t1.start(); 20 t2.start(); 21 22 } 23 }
這種實現的方式沒有類的單繼承性的侷限性更適合處理多個線程有共享數據的狀況。code
3、實現Callable接口對象
1.建立Callable的實現類blog
2.實現call方法，將此線程須要執行的操做聲明在call()中繼承
3.建立Callable接口實現類的對象
4.將此Callable接口實現類的對象做爲傳遞到FutureTask構造器中，建立FutureTask的對象
5.將FutureTask的對象做爲參數傳遞到Thread類的構造器中，建立Thread對象，並調用start()
6.獲取Callable中call方法的返回值
1 import java.util.concurrent.Callable; 2 import java.util.concurrent.ExecutionException; 3 import java.util.concurrent.FutureTask; 4 5 //1.建立Callable的實現類 6 class Test3 implements Callable<Object>{ 7 //2.實現call方法，將此線程須要執行的操做聲明在call()中 8 @Override 9 public Object call() throws Exception { 10 int sum = 0; 11 for (int i = 1; i <= 100; i++) { 12 if(i % 2 == 0){ 13 System.out.println(i); 14 sum += i; 15 } 16 } 17 return sum; 18 //若是不須要方法返回值 19 //return null; 20 } 21 } 22 23 24 public class ThreadTest3 { 25 public static void main(String[] args) { 26 //3.建立Callable接口實現類的對象 27 Test3 numThread = new Test3(); 28 //4.將此Callable接口實現類的對象做爲傳遞到FutureTask構造器中，建立FutureTask的對象 29 FutureTask futureTask = new FutureTask(numThread); 30 //5.將FutureTask的對象做爲參數傳遞到Thread類的構造器中，建立Thread對象，並調用start() 31 new Thread(futureTask).start();//用了匿名內部類
/*能夠和上面同樣寫成（至關於）：
Thread thread = new Thread(futureTask);
thread.start();
*/
32 33 try { 34 //6.獲取Callable中call方法的返回值 35 //get()返回值即爲FutureTask構造器參數Callable實現類重寫的call()的返回值。 36 Object sum = futureTask.get(); 37 System.out.println("總和爲：" + sum); 38 } catch (InterruptedException e) { 39 e.printStackTrace(); 40 } catch (ExecutionException e) { 41 e.printStackTrace(); 42 } 43 } 44 45 }
這種建立線程的方式更加的麻煩，可是人家相比較實現Runnable接口的方式更強大
相比實現Runnable接口的好處;
1. call()能夠有返回值
2. call()能夠拋出異常，被外面的操做捕獲，獲取異常的信息
3. Callable支持泛型
4、線程池
1. 提供指定線程數量的線程池
2.執行指定的線程的操做。須要提供實現Runnable接口或Callable接口實現類的對象
3.關閉鏈接池
1 import java.util.concurrent.ExecutorService; 2 import java.util.concurrent.Executors; 3 4 /** 5 * 這裏能夠用實現Runnable的方式 也能夠用實現Callable的方式 6 * 7 */ 8 class Test4 implements Runnable { 9 @Override 10 public void run() { 11 System.out.println("代碼"); 12 } 13 } 14 15 public class ThreadTest4 { 16 public static void main(String[] args) { 17 // 1. 提供指定線程數量的線程池 這裏設置爲10 18 ExecutorService service = Executors.newFixedThreadPool(10); 19 20 // 2.執行指定的線程的操做。須要提供實現Runnable接口或Callable接口實現類的對象 21 service.execute(new Test4());// 適合適用於Runnable 22 // service.submit(Callable callable);//適合使用於Callable 23 24 // 3.關閉鏈接池 25 service.shutdown(); 26 } 27 28 }
這種方式的好處：
1.提升響應速度（減小了建立新線程的時間）
2.下降資源消耗（重複利用線程池中線程，不須要每次都建立）
3.便於線程管理
以上簡單列舉了建立線程的四種方式，有很多東西沒有寫；尤爲是第四種，設置線程池屬性等都沒有演示。對於還在學習基礎的小夥伴來講，前兩種須要先重點掌握，後面兩種能夠先了解一下，等有一些多線程基礎以後再進行後續學習。