轉自:http://blog.csdn.net/javaniceyou/article/details/6859305

執行緒的兩種實現方式，通過實現Runnable介面的執行緒方式可以實現資源的共享，而繼承Thread則不可以，原因何在？先看下面兩段程式碼：

通過Thread實現執行緒：

1. //使用Thread實現執行緒不能實現資源共享 

1. //使用Thread實現執行緒不能實現資源共享
2. class MyThread extends Thread  
3. {     
4.     privateint ticket=5;  
5.     private String name;  
6.     public
    MyThread(String name ){  
7.         this.name=name;  
8.     }  
9.     publicvoid run(){  
10.         for(int i=0;i<10;i++){  
11.             if(ticket>5){  
12.                 System.out.println("執行緒"+name+"賣票"+i);  
13.             }  
14.         }  
15.     }  
16. }  
17. publicclass ThreadDemo02  
18. {  
19.     publicstaticvoid main(String args[]){  
20.         MyThread A = new MyThread("A");    
21.         MyThread B = new MyThread("B");  
22.         A.start();  
23.         B.start();  
24.     }  
25. }  

通過Runnable實現：

1.  
   1. //使用Runnable實現執行緒可以實現資源共享
   2. class MyThread implements Runnable  
   3. {  
   4.     privateint ticket=5;  
   5.     private String name;  
   6.     public
       MyThread(String name){  
   7.         this.name=name;  
   8.     }  
   9.     publicvoid run(){  
   10.         for(int i=1;i<=10;i++){  
   11.             if(ticket>0){  
   12.                 System.out.println("執行緒"+name+"賣票"+(ticket--));  
   13.                 }  
   14.         }  
   15.     }  
   16. }  
   17. publicclass RunnableDemo02  
   18. {  
   19.     publicstaticvoid main(String args[]){  
   20.         MyThread A = new MyThread("A");  //例項化執行緒要執行的任務
   21.         Thread Ta = new Thread(A);    //例項兩個執行緒物件，實際傳遞的是一個任務
   22.         Thread Tb = new Thread(A);    //因為兩個執行緒執行的是一個任務，所以資源是共享的
   23.         Ta.start();  
   24.         Tb.start();  
   25.     }  
   26. }  

解釋：

因為一個執行緒只能啟動一次，通過Thread實現執行緒時，執行緒和執行緒所要執行的任務是捆綁在一起的。也就使得一個任務只能啟動一個執行緒，不同的執行緒執行的任務是不相同的，所以沒有必要，也不能讓兩個執行緒共享彼此任務中的資源。

一個任務可以啟動多個執行緒，通過Runnable方式實現的執行緒，實際是開闢一個執行緒，將任務傳遞進去，由此執行緒執行。可以例項化多個 Thread物件，將同一任務傳遞進去，也就是一個任務可以啟動多個執行緒來執行它。這些執行緒執行的是同一個任務，所以他們的資源是共享。

兩種不同的執行緒實現方式本身就決定了其是否能進行資源共享。

個人理解：網上很多文章講述可以使用Runnable實現資源共享，當然有的使用繼承Thread也可以，但我還是表示懷疑這種做法是否真的可以實現資源共享，在共享資源的過程中並沒有使用同步欄位，這樣是否會引起資源衝突，還需進一步探討，如有牛人解釋，不勝感激！

找到以下解釋讓我感到我的想法是正確的。

我麼知道Java傳統多執行緒的實現有兩種方法,繼承Thread類或者實現Runnable即可.執行緒啟動時呼叫start()方法.

實現Runnable介面相比繼承Thread類有如下好處:

1.避免單繼承的侷限,一個類可以同時實現多個介面

2.適合資源的共享.

實現多執行緒模擬售票點賣票來說明實現Runnable即可可以達到資源共享的目的.

使用繼承Thread類的多執行緒售票實現

package org.dennist.thread.demo;/** * *  TicketThread.java     * *  @version ： 1.1 *   *  @author  ： 蘇若年    <a href="mailto:[email protected]">傳送郵件</a> *     *  @since     ： 1.0        建立時間:    2013-2-24        下午02:22:49 *      *  TODO     :    class TicketThread.java is used for ... * */public class TicketThreadT extends Thread{        private int num = 5;        //總共票數設定為5張        @Override    public void run() {        for(int i=0; i<10; i++){            if(this.num>0){        //列印買票資訊                System.out.println(Thread.currentThread().getName() + "買票: " + this.num--);            }        }    }        public static void main(String[] args) {        TicketThreadT th1 = new TicketThreadT();        //執行緒一        th1.setName("售票口一");            TicketThreadT th2 = new TicketThreadT();        //執行緒二        th2.setName("售票口二");        TicketThreadT th3 = new TicketThreadT();        //執行緒三        th3.setName("售票口三");                //分別啟動三個執行緒        th1.start();        th2.start();        th3.start();    }}

程式執行結果:

總共5張票,啟動了三個執行緒,從列印結果可以看出,一共賣出去了15張票,執行緒之間沒有進行資源共享

實現Runnable的售票執行緒

package org.dennist.thread.demo;/** * *  TicketThreadR.java     * *  @version ： 1.1 *   *  @author  ： 蘇若年    <a href="mailto:[email protected]">傳送郵件</a> *     *  @since     ： 1.0        建立時間:    2013-2-24        下午02:29:23 *      *  TODO     :    class TicketThreadR.java is used for ... * */public class TicketThreadR implements Runnable{        private int num = 5;            //總共票數設定為5張        @Override    public void run() {        for(int i=0; i<10; i++){            if(this.num>0){            //列印買票資訊                System.out.println(Thread.currentThread().getName() + "買票: " + this.num--);            }        }    }    public static void main(String[] args) {        TicketThreadR ticketThread = new TicketThreadR();                Thread th1 = new Thread(ticketThread);    //執行緒一        th1.setName("售票口一");        Thread th2 = new Thread(ticketThread);    //執行緒二        th2.setName("售票口二");        Thread th3 = new Thread(ticketThread);    //執行緒三        th3.setName("售票口三");                th1.start();        th2.start();        th3.start();    }}

程式執行結果

雖然現在程式中有三個執行緒,但是三個執行緒總共賣出了5張票,也就是說使用Runnable實現的多執行緒可以達到資源共享的目的.

Java多執行緒訪問共享方式

(1)如果每個執行緒執行的程式碼相同，可以使用同一個Runnable物件，這個Runnable物件中有那個共享資料，例如，買票系統就可以這麼做。

(2)如果每個執行緒執行的程式碼不同，這時候需要用不同的Runnable物件，有如下兩種方式來實現這些Runnable物件之間的資料共享：

　　1、將共享資料封裝在另外一個物件中，然後將這個物件逐一傳遞給各個Runnable物件。每個執行緒對共享資料的操作方法也分配到那個物件身上去完成，這樣容易實現針對該資料進行的各個操作的互斥和通訊。

　　2、將這些Runnable物件作為某一個類中的內部類，共享資料作為這個外部類中的成員變數，每個執行緒對共享資料的操作方法也分配給外部類，以便實現對共享資料進行的各個操作的互斥和通訊，作為內部類的各個Runnable物件呼叫外部類的這些方法。

　　3、上面兩種方式的組合：將共享資料封裝在另外一個物件中，每個執行緒對共享資料的操作方法也分配到那個物件身上去完成，物件作為這個外部類中的成員變數或方法中的區域性變數，每個執行緒的Runnable物件作為外部類中的成員內部類或區域性內部類。

　　4、總之，要同步互斥的幾段程式碼最好是分別放在幾個獨立的方法中，這些方法再放在同一個類中，這樣比較容易實現它們之間的同步互斥和通訊。

(3)極端且簡單的方式，即在任意一個類中定義一個static的變數，這將被所有執行緒共享。

在Thread類中存在以下的幾個方法可以設定和取得名字.

設定名字: public final void setName(String name) 

public Thread(Runnable target, String name)

public Thread(String name)

取得名字: public final String getName()

線上程的操作中因為其操作的不確定性,所以提供了一個方法,可以取得當前的操作執行緒.

public static Thread currentThread()

說明:

對於執行緒的名字一般是在啟動前進行設定,最好不要設定相同的名字,最好不要為一個執行緒改名字.

在Java執行中一個Java程式至少啟動2個執行緒:一個主執行緒和一個垃圾回收執行緒.

多執行緒的同步問題

上面的實現Runnable程式就真的沒問題了嗎？我們知道現實生活中買票總會有等待,跟延遲,那麼我們模擬現實生活中的買票然後再來看上面的程式輸出.

package org.dennist.thread.demo;/** * *  TicketThreadR.java     * *  @version ： 1.1 *   *  @author  ： 蘇若年    <a href="mailto:[email protected]">傳送郵件</a> *     *  @since     ： 1.0        建立時間:    2013-2-24        下午02:29:23 *      *  TODO     :    class TicketThreadR.java is used for ... * */public class TicketThreadR implements Runnable{        private int num = 5;            //總共票數設定為5張        @Override    public void run() {        for(int i=0; i<10; i++){            try {                Thread.sleep(200);    //休息200毫秒            } catch (InterruptedException e) {                e.printStackTrace();            }                    if(this.num>0){            //列印買票資訊                System.out.println(Thread.currentThread().getName() + "買票: " + this.num--);            }        }    }    public static void main(String[] args) {        TicketThreadR ticketThread = new TicketThreadR();                Thread th1 = new Thread(ticketThread);    //執行緒一        th1.setName("售票口一");        Thread th2 = new Thread(ticketThread);    //執行緒二        th2.setName("售票口二");        Thread th3 = new Thread(ticketThread);    //執行緒三        th3.setName("售票口三");                th1.start();        th2.start();        th3.start();    }}

如果想解決這樣的問題（這個問題我是沒有太看明白為何會輸出這樣的結果，兩個4是什麼情況下輸出的，雖然有問題，但是能確定的是如果要實現資源共享，必須的是有同步操作才可以，不然會出現執行緒安全問題，同步方法可以避免資源競爭）,就必須使用同步,所謂的同步就是指多個操作在同一個時間段內只有一個執行緒進行,其他執行緒要等待此執行緒完成之後才可以繼續執行.

可以通過同步程式碼的方法進行程式碼的加鎖操作,同步的實現有2中方法:

JAVA多執行緒同步主要依賴於若干方法和關鍵字
　　1  wait方法

　　2  notify方法和notifyAll方法

　　3  synchronized關鍵字

　　4 atomic action（原子操作）

此處針對上面情況使用同步關鍵字synchronized解決.同步關鍵字使用有2種方法

　　1.同步程式碼塊

　　2.同步方法

同步程式碼塊

使用synchronized關鍵字進行同步程式碼塊的宣告,但是在使用此操作時必須明確的指出到底要鎖定的是哪個物件,一般是以當前物件為主.

　　synchronized(物件){   //一般都是講this鎖定

         //鎖定物件

     }

上面的問題使用同步程式碼塊解決

package org.dennist.thread.demo;/** * *  TicketThreadR.java     * *  @version ： 1.1 *   *  @author  ： 蘇若年    <a href="mailto:[email protected]">傳送郵件</a> *     *  @since     ： 1.0        建立時間:    2013-2-24        下午02:29:23 *      *  TODO     :    class TicketThreadR.java is used for ... * */public class TicketThreadR implements Runnable{        private int num = 5;            //總共票數設定為5張        @Override    public void run() {        for(int i=0; i<10; i++){            //使用同步程式碼塊            synchronized (this) {                try {                    Thread.sleep(300);    //休息300毫秒                } catch (InterruptedException e) {                    e.printStackTrace();                }                        if(this.num>0){                        //列印買票資訊                    System.out.println(Thread.currentThread().getName() + "買票: " + this.num--);                }            }                    }    }    public static void main(String[] args) {        TicketThreadR ticketThread = new TicketThreadR();                new Thread(ticketThread,"售票口一").start();    //執行緒一        new Thread(ticketThread,"售票口二").start();    //執行緒二        new Thread(ticketThread,"售票口三").start();    //執行緒三    }}

同步方法

同步方法是在方法上增加synchronized關鍵字修飾
上面的問題使用同步程式碼塊解決

package org.dennist.thread.demo;/** * *  TicketThreadR.java     * *  @version ： 1.1 *   *  @author  ： 蘇若年    <a href="mailto:[email protected]">傳送郵件</a> *     *  @since     ： 1.0        建立時間:    2013-2-24        下午02:29:23 *      *  TODO     :    class TicketThreadR.java is used for ... * */public class TicketThreadR implements Runnable{        private int num = 5;            //總共票數設定為5張        @Override    public void run() {        for(int i=0; i<10; i++){            sale();                    //呼叫同步方法        }    }        //使用同步方法    public synchronized void sale(){        try {            Thread.sleep(300);    //休息300毫秒        } catch (InterruptedException e) {            e.printStackTrace();        }                if(this.num>0){                //列印買票資訊            System.out.println(Thread.currentThread().getName() + "買票: " + this.num--);        }    }        public static void main(String[] args) {        TicketThreadR ticketThread = new TicketThreadR();                new Thread(ticketThread,"售票口一").start();    //執行緒一        new Thread(ticketThread,"售票口二").start();    //執行緒一        new Thread(ticketThread,"售票口三").start();    //執行緒一    }}

多個執行緒共享同一資源的時候需要進行同步,但是過多的同步會造成死鎖.

什麼叫死鎖？死鎖產生的主要原因是什麼？死鎖產生的必要條件,如何解決死鎖?​

死鎖指在多道程式系統中,一組程序中的每一個程序均無限期的等待該被改組程序中的另一個程序所以佔有且永遠不會釋放的資源,這種現象稱為系統處於死鎖狀態.​

死鎖產生的原因主要有2個:​

　　1.競爭資源,系統提供的資源數量有限,不能滿足每個程序的要求​

　　2.多道程式執行時,.程序推進順序不合理​

產生死鎖的必要條件​

　　1.互斥使用資源​

　　2.佔用並等待資源​

　　3.不可搶奪資源​

　　4.迴圈等待資源​

解決死鎖的方法​

　　1.預防死鎖:破壞死鎖產生的條件(除過互斥條件,因為破壞互斥條件不現實)​

　　2.避免死鎖​

　　3.檢測與排除​

　　4.置之不理​