寫在前面的話：此文只能說是java多執行緒的一個入門，其實Java裡頭執行緒完全可以寫一本書了，但是如果最基本的你都學掌握好，又怎麼能更上一個臺階呢？如果你覺得此文很簡單，那推薦你看看Java併發包的的執行緒池（Java併發程式設計與技術內幕:執行緒池深入理解），或者看這個專欄：Java併發程式設計與技術內幕。你將會對Java裡頭的高併發場景下的執行緒有更加深刻的理解。

目錄(?)[-]

        本文主要講了java中多執行緒的使用方法、執行緒同步、執行緒資料傳遞、執行緒狀態及相應的一些執行緒函式用法、概述等。在這之前，首先讓我們來了解下在作業系統中程序和執行緒的區別：

　　程序：每個程序都有獨立的程式碼和資料空間（程序上下文），程序間的切換會有較大的開銷，一個程序包含1--n個執行緒。（程序是資源分配的最小單位）

　　執行緒：同一類執行緒共享程式碼和資料空間，每個執行緒有獨立的執行棧和程式計數器(PC)，執行緒切換開銷小。（執行緒是cpu排程的最小單位）

　　執行緒和程序一樣分為五個階段：建立、就緒、執行、阻塞、終止。

　　多程序是指作業系統能同時執行多個任務（程式）。

　　多執行緒是指在同一程式中有多個順序流在執行。

在java中要想實現多執行緒，有兩種手段，一種是繼續Thread類，另外一種是實現Runable介面.(其實準確來講，應該有三種，還有一種是實現Callable介面

，並與Future、執行緒池結合使用，此文這裡不講這個，有興趣看這裡Java併發程式設計與技術內幕:Callable、Future、FutureTask、CompletionService)

一、擴充套件java.lang.Thread類

這裡繼承Thread類的方法是比較常用的一種，如果說你只是想起一條執行緒。沒有什麼其它特殊的要求，那麼可以使用Thread.（筆者推薦使用Runable，後頭會說明為什麼）。下面來看一個簡單的例項

1. package com.multithread.learning;  
2. /** 
3.  *@functon 多執行緒學習 
4.  *@author 林炳文
    
5.  *@time 2015.3.9 
6.  */
7. class Thread1 extends Thread{  
8.     private String name;  
9.     public Thread1(String name) {  
10.        this.name=name;  
11.     }  
12.     publicvoid run() {  
13.         for (int i = 0; i < 5; i++) {  
14.             System.out.println(name + "執行  :  " + i);  
15.             try {  
16.                 sleep((int) Math.random() * 10);  
17.             } catch (InterruptedException e) {  
18.                 e.printStackTrace();  
19.             }  
20.         }  
21.     }  
22. }  
23. publicclass Main {  
24.     publicstaticvoid main(String[] args) {  
25.         Thread1 mTh1=new Thread1("A");  
26.         Thread1 mTh2=new Thread1("B");  
27.         mTh1.start();  
28.         mTh2.start();  
29.     }  
30. }  

輸出：

A執行  :  0
B執行  :  0
A執行  :  1
A執行  :  2
A執行  :  3
A執行  :  4
B執行  :  1
B執行  :  2
B執行  :  3
B執行  :  4

再執行一下：

A執行  :  0
B執行  :  0
B執行  :  1
B執行  :  2
B執行  :  3
B執行  :  4
A執行  :  1
A執行  :  2
A執行  :  3
A執行  :  4
說明： 程式啟動執行main時候，java虛擬機器啟動一個程序，主執行緒main在main()呼叫時候被建立。隨著呼叫MitiSay的兩個物件的start方法，另外兩個執行緒也啟動了，這樣，整個應用就在多執行緒下執行。 注意：start()方法的呼叫後並不是立即執行多執行緒程式碼，而是使得該執行緒變為可執行態（Runnable），什麼時候執行是由作業系統決定的。 從程式執行的結果可以發現，多執行緒程式是亂序執行。因此，只有亂序執行的程式碼才有必要設計為多執行緒。 Thread.sleep()方法呼叫目的是不讓當前執行緒獨自霸佔該程序所獲取的CPU資源，以留出一定時間給其他執行緒執行的機會。 實際上所有的多執行緒程式碼執行順序都是不確定的，每次執行的結果都是隨機的。

但是start方法重複呼叫的話，會出現java.lang.IllegalThreadStateException異常。

1. Thread1 mTh1=new Thread1("A");  
2. Thread1 mTh2=mTh1;  
3. mTh1.start();  
4. mTh2.start();  

輸出：

Exception in thread "main" java.lang.IllegalThreadStateException
    at java.lang.Thread.start(Unknown Source)
    at com.multithread.learning.Main.main(Main.java:31)
A執行  :  0
A執行  :  1
A執行  :  2
A執行  :  3
A執行  :  4

二、實現java.lang.Runnable介面

採用Runnable也是非常常見的一種，我們只需要重寫run方法即可。下面也來看個例項。

1. /** 
2.  *@functon 多執行緒學習 
3.  *@author 林炳文 
4.  *@time 2015.3.9 
5.  */
6. package com.multithread.runnable;  
7. class Thread2 implements Runnable{  
8.     private String name;  
9.     public Thread2(String name) {  
10.         this.name=name;  
11.     }  
12.     @Override
13.     publicvoid run() {  
14.           for (int i = 0; i < 5; i++) {  
15.                 System.out.println(name + "執行  :  " + i);  
16.                 try {  
17.                     Thread.sleep((int) Math.random() * 10);  
18.                 } catch (InterruptedException e) {  
19.                     e.printStackTrace();  
20.                 }  
21.             }  
22.     }  
23. }  
24. publicclass Main {  
25.     publicstaticvoid main(String[] args) {  
26.         new Thread(new Thread2("C")).start();  
27.         new Thread(new Thread2("D")).start();  
28.     }  
29. }  

輸出：

C執行  :  0
D執行  :  0
D執行  :  1
C執行  :  1
D執行  :  2
C執行  :  2
D執行  :  3
C執行  :  3
D執行  :  4
C執行  :  4

說明： Thread2類通過實現Runnable介面，使得該類有了多執行緒類的特徵。run（）方法是多執行緒程式的一個約定。所有的多執行緒程式碼都在run方法裡面。Thread類實際上也是實現了Runnable介面的類。 在啟動的多執行緒的時候，需要先通過Thread類的構造方法Thread(Runnable target) 構造出物件，然後呼叫Thread物件的start()方法來執行多執行緒程式碼。 實際上所有的多執行緒程式碼都是通過執行Thread的start()方法來執行的。因此，不管是擴充套件Thread類還是實現Runnable介面來實現多執行緒，最終還是通過Thread的物件的API來控制執行緒的，熟悉Thread類的API是進行多執行緒程式設計的基礎。

三、Thread和Runnable的區別

如果一個類繼承Thread，則不適合資源共享。但是如果實現了Runable介面的話，則很容易的實現資源共享。

總結：

實現Runnable介面比繼承Thread類所具有的優勢：

1）：適合多個相同的程式程式碼的執行緒去處理同一個資源

2）：可以避免java中的單繼承的限制

3）：增加程式的健壯性，程式碼可以被多個執行緒共享，程式碼和資料獨立

4）：執行緒池只能放入實現Runable或callable類執行緒，不能直接放入繼承Thread的類

提醒一下大家：main方法其實也是一個執行緒。在java中所以的執行緒都是同時啟動的，至於什麼時候，哪個先執行，完全看誰先得到CPU的資源。

在java中，每次程式執行至少啟動2個執行緒。一個是main

相關推薦