林炳文Evankaka原創作品。轉載請註明出處http://blog.csdn.net/evankaka

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

目錄(?)[-]

1. 一擴充套件javalangThread類
2. 二實現javalangRunnable介面
3. 三Thread和Runnable的區別
4. 四執行緒狀態轉換
5. 五執行緒排程
6. 六常用函式說明
   1. 使用方式
   2. 為什麼要用join方法
7. 七常見執行緒名詞解釋
8. 八執行緒同步
9. 九執行緒資料傳遞

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

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

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

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

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

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

在java中要想實現多執行緒，有兩種手段，一種是繼續Thread類，另外一種是實現Runable介面.(其實準確來講，應該有三種，還有一種是實現Callable介面，並與Future、執行緒池結合使用，此文這裡不講這個，有興趣看這裡Java併發程式設計與技術內幕:Callable、Future、FutureTask、CompletionService )

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

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

package com.multithread.learning;
/**
 *@functon 多執行緒學習
 *@author 林炳文
 *@time 2015.3.9
 */
class Thread1 extends Thread{
	private String name;
    public Thread1(String name) {
       this.name=name;
    }
	public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(name + "執行  :  " + i);
            try {
                sleep((int) Math.random() * 10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
       
	}
}
public class Main {

	public static void main(String[] args) {
		Thread1 mTh1=new Thread1("A");
		Thread1 mTh2=new Thread1("B");
		mTh1.start();
		mTh2.start();

	}

}

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

再執行一下：

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

		Thread1 mTh1=new Thread1("A");
		Thread1 mTh2=mTh1;
		mTh1.start();
		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方法即可。下面也來看個例項。

/**
 *@functon 多執行緒學習
 *@author 林炳文
 *@time 2015.3.9
 */
package com.multithread.runnable;
class Thread2 implements Runnable{
	private String name;

	public Thread2(String name) {
		this.name=name;
	}

	@Override
	public void run() {
		  for (int i = 0; i < 5; i++) {
	            System.out.println(name + "執行  :  " + i);
	            try {
	            	Thread.sleep((int) Math.random() * 10);
	            } catch (InterruptedException e) {
	                e.printStackTrace();
	            }
	        }
		
	}
	
}
public class Main {

	public static void main(String[] args) {
		new Thread(new Thread2("C")).start();
		new Thread(new Thread2("D")).start();
	}

}

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

總結：

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

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

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

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

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

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

在java中，每次程式執行至少啟動2個執行緒。一個是main執行緒，一個是垃圾收集執行緒。因為每當使用java命令執行一個類的時候，實際上都會啟動一個ＪＶＭ，每一個ｊＶＭ實習在就是在作業系統中啟動了一個程式。

四、執行緒狀態轉換

五、執行緒排程

執行緒的排程

static int MAX_PRIORITY
          執行緒可以具有的最高優先順序，取值為10。
static int MIN_PRIORITY
          執行緒可以具有的最低優先順序，取值為1。
static int NORM_PRIORITY
          分配給執行緒的預設優先順序，取值為5。

Thread t = new AThread(); t.start(); t.join();

/**
 *@functon 多執行緒學習,join
 *@author 林炳文
 *@time 2015.3.9
 */
package com.multithread.join;
class Thread1 extends Thread{
	private String name;
    public Thread1(String name) {
    	super(name);
       this.name=name;
    }
	public void run() {
		System.out.println(Thread.currentThread().getName() + " 執行緒執行開始!");
        for (int i = 0; i < 5; i++) {
            System.out.println("子執行緒"+name + "執行 : " + i);
            try {
                sleep((int) Math.random() * 10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName() + " 執行緒執行結束!");
	}
}

public class Main {

	public static void main(String[] args) {
		System.out.println(Thread.currentThread().getName()+"主執行緒執行開始!");
		Thread1 mTh1=new Thread1("A");
		Thread1 mTh2=new Thread1("B");
		mTh1.start();
		mTh2.start();
		System.out.println(Thread.currentThread().getName()+ "主執行緒執行結束!");

	}

}

public class Main {

	public static void main(String[] args) {
		System.out.println(Thread.currentThread().getName()+"主執行緒執行開始!");
		Thread1 mTh1=new Thread1("A");
		Thread1 mTh2=new Thread1("B");
		mTh1.start();
		mTh2.start();
		try {
			mTh1.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		try {
			mTh2.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName()+ "主執行緒執行結束!");

	}

}

/**
 *@functon 多執行緒學習 yield
 *@author 林炳文
 *@time 2015.3.9
 */
package com.multithread.yield;
class ThreadYield extends Thread{
    public ThreadYield(String name) {
        super(name);
    }
 
    @Override
    public void run() {
        for (int i = 1; i <= 50; i++) {
            System.out.println("" + this.getName() + "-----" + i);
            // 當i為30時，該執行緒就會把CPU時間讓掉，讓其他或者自己的執行緒執行（也就是誰先搶到誰執行）
            if (i ==30) {
                this.yield();
            }
        }
	
}
}

public class Main {

	public static void main(String[] args) {
		
		ThreadYield yt1 = new ThreadYield("張三");
    	ThreadYield yt2 = new ThreadYield("李四");
        yt1.start();
        yt2.start();
	}

}

Thread4 t1 = new Thread4("t1");
Thread4 t2 = new Thread4("t2");
t1.setPriority(Thread.MAX_PRIORITY);
t2.setPriority(Thread.MIN_PRIORITY);

/**
 * wait用法
 * @author DreamSea 
 * @time 2015.3.9 
 */
package com.multithread.wait;
public class MyThreadPrinter2 implements Runnable {   
	  
    private String name;   
    private Object prev;   
    private Object self;   
  
    private MyThreadPrinter2(String name, Object prev, Object self) {   
        this.name = name;   
        this.prev = prev;   
        this.self = self;   
    }   
  
    @Override  
    public void run() {   
        int count = 10;   
        while (count > 0) {   
            synchronized (prev) {   
                synchronized (self) {   
                    System.out.print(name);   
                    count--;  
                    
                    self.notify();   
                }   
                try {   
                    prev.wait();   
                } catch (InterruptedException e) {   
                    e.printStackTrace();   
                }   
            }   
  
        }   
    }   
  
    public static void main(String[] args) throws Exception {   
        Object a = new Object();   
        Object b = new Object();   
        Object c = new Object();   
        MyThreadPrinter2 pa = new MyThreadPrinter2("A", c, a);   
        MyThreadPrinter2 pb = new MyThreadPrinter2("B", a, b);   
        MyThreadPrinter2 pc = new MyThreadPrinter2("C", b, c);   
           
           
        new Thread(pa).start();
        Thread.sleep(100);  //確保按順序A、B、C執行
        new Thread(pb).start();
        Thread.sleep(100);  
        new Thread(pc).start();   
        Thread.sleep(100);  
        }   
}  

八、執行緒同步

1、synchronized關鍵字的作用域有二種：
1）是某個物件例項內，synchronized aMethod(){}可以防止多個執行緒同時訪問這個物件的synchronized方法（如果一個物件有多個synchronized方法，只要一個執行緒訪問了其中的一個synchronized方法，其它執行緒不能同時訪問這個物件中任何一個synchronized方法）。這時，不同的物件例項的synchronized方法是不相干擾的。也就是說，其它執行緒照樣可以同時訪問相同類的另一個物件例項中的synchronized方法；
2）是某個類的範圍，synchronized static aStaticMethod{}防止多個執行緒同時訪問這個類中的synchronized static 方法。它可以對類的所有物件例項起作用。

2、除了方法前用synchronized關鍵字，synchronized關鍵字還可以用於方法中的某個區塊中，表示只對這個區塊的資源實行互斥訪問。用法是: synchronized(this){/*區塊*/}，它的作用域是當前物件；

3、synchronized關鍵字是不能繼承的，也就是說，基類的方法synchronized f(){} 在繼承類中並不自動是synchronized f(){}，而是變成了f(){}。繼承類需要你顯式的指定它的某個方法為synchronized方法；

Java對多執行緒的支援與同步機制深受大家的喜愛，似乎看起來使用了synchronized關鍵字就可以輕鬆地解決多執行緒共享資料同步問題。到底如何？――還得對synchronized關鍵字的作用進行深入瞭解才可定論。

總的說來，synchronized關鍵字可以作為函式的修飾符，也可作為函式內的語句，也就是平時說的同步方法和同步語句塊。如果再細的分類，synchronized可作用於instance變數、object reference（物件引用）、static函式和class literals(類名稱字面常量)身上。

在進一步闡述之前，我們需要明確幾點：

A．無論synchronized關鍵字加在方法上還是物件上，它取得的鎖都是物件，而不是把一段程式碼或函式當作鎖――而且同步方法很可能還會被其他執行緒的物件訪問。

B．每個物件只有一個鎖（lock）與之相關聯。

C．實現同步是要很大的系統開銷作為代價的，甚至可能造成死鎖，所以儘量避免無謂的同步控制。

接著來討論synchronized用到不同地方對程式碼產生的影響：

假設P1、P2是同一個類的不同物件，這個類中定義了以下幾種情況的同步塊或同步方法，P1、P2就都可以呼叫它們。

1．  把synchronized當作函式修飾符時，示例程式碼如下：

Public synchronized void methodAAA()
{
//….
}

這也就是同步方法，那這時synchronized鎖定的是哪個物件呢？它鎖定的是呼叫這個同步方法物件。也就是說，當一個物件P1在不同的執行緒中執行這個同步方法時，它們之間會形成互斥，達到同步的效果。但是這個物件所屬的Class所產生的另一物件P2卻可以任意呼叫這個被加了synchronized關鍵字的方法。

上邊的示例程式碼等同於如下程式碼：

public void methodAAA()
{
synchronized (this)      //  (1)
{
       //…..
}
}

 (1)處的this指的是什麼呢？它指的就是呼叫這個方法的物件，如P1。可見同步方法實質是將synchronized作用於object reference。――那個拿到了P1物件鎖的執行緒，才可以呼叫P1的同步方法，而對P2而言，P1這個鎖與它毫不相干，程式也可能在這種情形下襬脫同步機制的控制，造成資料混亂：（

2．同步塊，示例程式碼如下：

            public void method3(SomeObject so)
              {
                     synchronized(so)
{
       //…..
}
}

這時，鎖就是so這個物件，誰拿到這個鎖誰就可以執行它所控制的那段程式碼。當有一個明確的物件作為鎖時，就可以這樣寫程式，但當沒有明確的物件作為鎖，只是想讓一段程式碼同步時，可以建立一個特殊的instance變數（它得是一個物件）來充當鎖：

class Foo implements Runnable
{
       private byte[] lock = new byte[0];  // 特殊的instance變數
    Public void methodA()
{
       synchronized(lock) { //… }
}
//…..
}

注：零長度的byte陣列物件建立起來將比任何物件都經濟――檢視編譯後的位元組碼：生成零長度的byte[]物件只需3條操作碼，而Object lock = new Object()則需要7行操作碼。

3．將synchronized作用於static 函式，示例程式碼如下：

Class Foo
{
public synchronized static void methodAAA()   // 同步的static 函式
{
//….
}
public void methodBBB()
{
       synchronized(Foo.class)   //  class literal(類名稱字面常量)
}
       }

   程式碼中的methodBBB()方法是把class literal作為鎖的情況，它和同步的static函式產生的效果是一樣的，取得的鎖很特別，是當前呼叫這個方法的物件所屬的類（Class，而不再是由這個Class產生的某個具體物件了）。

記得在《Effective Java》一書中看到過將 Foo.class和 P1.getClass()用於作同步鎖還不一樣，不能用P1.getClass()來達到鎖這個Class的目的。P1指的是由Foo類產生的物件。

可以推斷：如果一個類中定義了一個synchronized的static函式A，也定義了一個synchronized 的instance函式B，那麼這個類的同一物件Obj在多執行緒中分別訪問A和B兩個方法時，不會構成同步，因為它們的鎖都不一樣。A方法的鎖是Obj這個物件，而B的鎖是Obj所屬的那個Class。

總結一下：

1、執行緒同步的目的是為了保護多個執行緒反問一個資源時對資源的破壞。
2、執行緒同步方法是通過鎖來實現，每個物件都有切僅有一個鎖，這個鎖與一個特定的物件關聯，執行緒一旦獲取了物件鎖，其他訪問該物件的執行緒就無法再訪問該物件的其他非同步方法
3、對於靜態同步方法，鎖是針對這個類的，鎖物件是該類的Class物件。靜態和非靜態方法的鎖互不干預。一個執行緒獲得鎖，當在一個同步方法中訪問另外物件上的同步方法時，會獲取這兩個物件鎖。
4、對於同步，要時刻清醒在哪個物件上同步，這是關鍵。
5、編寫執行緒安全的類，需要時刻注意對多個執行緒競爭訪問資源的邏輯和安全做出正確的判斷，對“原子”操作做出分析，並保證原子操作期間別的執行緒無法訪問競爭資源。
6、當多個執行緒等待一個物件鎖時，沒有獲取到鎖的執行緒將發生阻塞。
7、死鎖是執行緒間相互等待鎖鎖造成的，在實際中發生的概率非常的小。真讓你寫個死鎖程式，不一定好使，呵呵。但是，一旦程式發生死鎖，程式將死掉。

九、執行緒資料傳遞

在傳統的同步開發模式下，當我們呼叫一個函式時，通過這個函式的引數將資料傳入，並通過這個函式的返回值來返回最終的計算結果。但在多執行緒的非同步開發模式下，資料的傳遞和返回和同步開發模式有很大的區別。由於執行緒的執行和結束是不可預料的，因此，在傳遞和返回資料時就無法象函式一樣通過函式引數和return語句來返回資料。

9.1、通過構造方法傳遞資料 
在建立執行緒時，必須要建立一個Thread類的或其子類的例項。因此，我們不難想到在呼叫start方法之前通過執行緒類的構造方法將資料傳入執行緒。並將傳入的資料使用類變數儲存起來，以便執行緒使用(其實就是在run方法中使用)。下面的程式碼演示瞭如何通過構造方法來傳遞資料： 

 
package mythread; 
public class MyThread1 extends Thread 
{ 
private String name; 
public MyThread1(String name) 
{ 
this.name = name; 
} 
public void run() 
{ 
System.out.println("hello " + name); 
} 
public static void main(String[] args) 
{ 
Thread thread = new MyThread1("world"); 
thread.start(); 
} 
} 

9.2、通過變數和方法傳遞資料 
向物件中傳入資料一般有兩次機會，第一次機會是在建立物件時通過構造方法將資料傳入，另外一次機會就是在類中定義一系列的public的方法或變數（也可稱之為欄位）。然後在建立完物件後，通過物件例項逐個賦值。下面的程式碼是對MyThread1類的改版，使用了一個setName方法來設定 name變數： 

 
package mythread; 
public class MyThread2 implements Runnable 
{ 
private String name; 
public void setName(String name) 
{ 
this.name = name; 
} 
public void run() 
{ 
System.out.println("hello " + name); 
} 
public static void main(String[] args) 
{ 
MyThread2 myThread = new MyThread2(); 
myThread.setName("world"); 
Thread thread = new Thread(myThread); 
thread.start(); 
} 
} 

上面討論的兩種向執行緒中傳遞資料的方法是最常用的。但這兩種方法都是main方法中主動將資料傳入執行緒類的。這對於執行緒來說，是被動接收這些資料的。然而，在有些應用中需要線上程執行的過程中動態地獲取資料，如在下面程式碼的run方法中產生了3個隨機數，然後通過Work類的process方法求這三個隨機數的和，並通過Data類的value將結果返回。從這個例子可以看出，在返回value之前，必須要得到三個隨機數。也就是說，這個 value是無法事先就傳入執行緒類的。 

 
package mythread; 
class Data 
{ 
public int value = 0; 
} 
class Work 
{ 
public void process(Data data, Integer numbers) 
{ 
for (int n : numbers) 
{ 
data.value += n; 
} 
} 
} 
public class MyThread3 extends Thread 
{ 
private Work work; 
public MyThread3(Work work) 
{ 
this.work = work; 
} 
public void run() 
{ 
java.util.Random random = new java.util.Random(); 
Data data = new Data(); 
int n1 = random.nextInt(1000); 
int n2 = random.nextInt(2000); 
int n3 = random.nextInt(3000); 
work.process(data, n1, n2, n3); // 使用回撥函式 
System.out.println(String.valueOf(n1) + "+" + String.valueOf(n2) + "+" 
+ String.valueOf(n3) + "=" + data.value); 
} 
public static void main(String[] args) 
{ 
Thread thread = new MyThread3(new Work()); 
thread.start(); 
} 
} 

  好了，Java多執行緒的基礎知識就講到這裡了，有興趣研究多執行緒的推薦直接看java的原始碼，你將會得到很大的提升！

林炳文Evankaka原創作品。轉載請註明出處http://blog.csdn.net/evankaka