Java多線程學習（吐血超詳細總結）

目錄(?)[-]

1. 一擴展javalangThread類

2. 二實現javalangRunnable接口

3. 三Thread和Runnable的區別

4. 四線程狀態轉換

5. 五線程調度

6. 六經常使用函數說明

1. 使用方式

2. 爲何要用join方法

7. 七常見線程名詞解釋

8. 八線程同步

9. 九線程數據傳遞

     本文主要講了java中多線程的使用方法、線程同步、線程數據傳遞、線程狀態及相應的一些線程函數用法、概述等。

首先講一下進程和線程的區別：

　　進程：每一個進程都有獨立的代碼和數據空間（進程上下文），進程間的切換會有較大的開銷，一個進程包含1--n個線程。

　　線程：同一類線程共享代碼和數據空間，每一個線程有獨立的運行棧和程序計數器(PC)，線程切換開銷小。

　　線程和進程同樣分爲五個階段：建立、就緒、運行、阻塞、終止。

　　多進程是指操做系統能同時運行多個任務（程序）。

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

在java中要想實現多線程，有兩種手段，一種是繼續Thread類，另一種是實現Runable接口。

1、擴展java.lang.Thread類

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

再運行一下：

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異常。

 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

2、實現java.lang.Runnable接口

/**
 *@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

說明：Thread2類經過實現Runnable接口，使得該類有了多線程類的特徵。run（）方法是多線程程序的一個約定。全部的多線程代碼都在run方法裏面。Thread類實際上也是實現了Runnable接口的類。在啓動的多線程的時候，須要先經過Thread類的構造方法Thread(Runnable target) 構造出對象，而後調用Thread對象的start()方法來運行多線程代碼。實際上全部的多線程代碼都是經過運行Thread的start()方法來運行的。所以，無論是擴展Thread類仍是實現Runnable接口來實現多線程，最終仍是經過Thread的對象的API來控制線程的，熟悉Thread類的API是進行多線程編程的基礎。

3、Thread和Runnable的區別

若是一個類繼承Thread，則不適合資源共享。可是若是實現了Runable接口的話，則很容易的實現資源共享。

package com.carl.test.thread.test;

/**
 * Created by Carl on 15-10-21.
 */
public class Thread1 extends Thread{
    private int count = 5;
    private String name;

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

    @Override
    public void run() {
        for(int i =0;i<5;i++){
            System.out.println(name+",運行：count="+count--);
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Main {
    public static void main(String [] args){
        Thread1 t1 = new Thread1("T1");
        Thread1 t2 = new Thread1("T2");
        t1.start();
        t2.start();
    }
}

輸出：

B運行  count= 5
A運行  count= 5
B運行  count= 4
B運行  count= 3
B運行  count= 2
B運行  count= 1
A運行  count= 4
A運行  count= 3
A運行  count= 2
A運行  count= 1

從上面能夠看出，不一樣的線程之間count是不一樣的，這對於賣票系統來講就會有很大的問題，固然，這裏能夠用同步來做。這裏咱們用Runnable來作下看看

package com.carl.test.thread.test;

/**
 * Created by Carl on 15-10-21.
 */
public class Thread2 implements Runnable{

    private int count = 15;

    @Override
    public void run() {
        for(int i =0;i<5;i++){
            synchronized(this){
                System.out.println(Thread.currentThread().getName()+",運行 count="+count--);
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

}

public class Main {
    public static void main(String [] args){
        Thread2 run = new Thread2();
        new Thread(run,"C").start();
        new Thread(run,"D").start();
        new Thread(run,"E").start();
    }
}

輸出：

C運行  count= 15
D運行  count= 14
E運行  count= 13
D運行  count= 12
D運行  count= 10
D運行  count= 9
D運行  count= 8
C運行  count= 11
E運行  count= 12
C運行  count= 7
E運行  count= 6
C運行  count= 5
E運行  count= 4
C運行  count= 3
E運行  count= 2

這裏要注意每一個線程都是用同一個實例化對象，若是不是同一個，效果就和上面的同樣了！

總結：

實現Runnable接口比繼承Thread類所具備的優點：

1）：適合多個相同的程序代碼的線程去處理同一個資源

2）：能夠避免java中的單繼承的限制

3）：增長程序的健壯性，代碼能夠被多個線程共享，代碼和數據獨立

提醒一下你們：main方法其實也是一個線程。在java中因此的線程都是同時啓動的，至於何時，哪一個先執行，徹底看誰先獲得CPU的資源。

 

在java中，每次程序運行至少啓動2個線程。一個是main線程，一個是垃圾收集線程。由於每當使用java命令執行一個類的時候，實際上都會啓動一個ＪＶＭ，每個ｊＶＭ實習在就是在操做系統中啓動了一個進程。

4、線程狀態轉換

一、新建狀態（New）：新建立了一個線程對象。二、就緒狀態（Runnable）：線程對象建立後，其餘線程調用了該對象的start()方法。該狀態的線程位於可運行線程池中，變得可運行，等待獲取CPU的使用權。三、運行狀態（Running）：就緒狀態的線程獲取了CPU，執行程序代碼。四、阻塞狀態（Blocked）：阻塞狀態是線程由於某種緣由放棄CPU使用權，暫時中止運行。直到線程進入就緒狀態，纔有機會轉到運行狀態。阻塞的狀況分三種：（一）、等待阻塞：運行的線程執行wait()方法，JVM會把該線程放入等待池中。（二）、同步阻塞：運行的線程在獲取對象的同步鎖時，若該同步鎖被別的線程佔用，則JVM會把該線程放入鎖池中。（三）、其餘阻塞：運行的線程執行sleep()或join()方法，或者發出了I/O請求時，JVM會把該線程置爲阻塞狀態。當sleep()狀態超時、join()等待線程終止或者超時、或者I/O處理完畢時，線程從新轉入就緒狀態。五、死亡狀態（Dead）：線程執行完了或者因異常退出了run()方法，該線程結束生命週期。

5、線程調度

線程的調度

一、調整線程優先級：Java線程有優先級，優先級高的線程會得到較多的運行機會。 Java線程的優先級用整數表示，取值範圍是1~10，Thread類有如下三個靜態常量：static int MAX_PRIORITY          線程能夠具備的最高優先級，取值爲10。static int MIN_PRIORITY          線程能夠具備的最低優先級，取值爲1。static int NORM_PRIORITY          分配給線程的默認優先級，取值爲5。 Thread類的setPriority()和getPriority()方法分別用來設置和獲取線程的優先級。 每一個線程都有默認的優先級。主線程的默認優先級爲Thread.NORM_PRIORITY。線程的優先級有繼承關係，好比A線程中建立了B線程，那麼B將和A具備相同的優先級。JVM提供了10個線程優先級，但與常見的操做系統都不能很好的映射。若是但願程序能移植到各個操做系統中，應該僅僅使用Thread類有如下三個靜態常量做爲優先級，這樣能保證一樣的優先級採用了一樣的調度方式。 二、線程睡眠：Thread.sleep(long millis)方法，使線程轉到阻塞狀態。millis參數設定睡眠的時間，以毫秒爲單位。當睡眠結束後，就轉爲就緒（Runnable）狀態。sleep()平臺移植性好。 三、線程等待：Object類中的wait()方法，致使當前的線程等待，直到其餘線程調用此對象的 notify() 方法或 notifyAll() 喚醒方法。這個兩個喚醒方法也是Object類中的方法，行爲等價於調用 wait(0) 同樣。 四、線程讓步：Thread.yield() 方法，暫停當前正在執行的線程對象，把執行機會讓給相同或者更高優先級的線程。 五、線程加入：join()方法，等待其餘線程終止。在當前線程中調用另外一個線程的join()方法，則當前線程轉入阻塞狀態，直到另外一個進程運行結束，當前線程再由阻塞轉爲就緒狀態。 六、線程喚醒：Object類中的notify()方法，喚醒在此對象監視器上等待的單個線程。若是全部線程都在此對象上等待，則會選擇喚醒其中一個線程。選擇是任意性的，並在對實現作出決定時發生。線程經過調用其中一個 wait 方法，在對象的監視器上等待。 直到當前的線程放棄此對象上的鎖定，才能繼續執行被喚醒的線程。被喚醒的線程將以常規方式與在該對象上主動同步的其餘全部線程進行競爭；例如，喚醒的線程在做爲鎖定此對象的下一個線程方面沒有可靠的特權或劣勢。相似的方法還有一個notifyAll()，喚醒在此對象監視器上等待的全部線程。 注意：Thread中suspend()和resume()兩個方法在JDK1.5中已經廢除，再也不介紹。由於有死鎖傾向。

6、經常使用函數說明

①sleep(long millis): 在指定的毫秒數內讓當前正在執行的線程休眠（暫停執行）

②join():指等待t線程終止。

使用方式。

join是Thread類的一個方法，啓動線程後直接調用，即join()的做用是：「等待該線程終止」，這裏須要理解的就是該線程是指的主線程等待子線程的終止。也就是在子線程調用了join()方法後面的代碼，只有等到子線程結束了才能執行。

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

爲何要用join()方法

在不少狀況下，主線程生成並起動了子線程，若是子線程裏要進行大量的耗時的運算，主線程每每將於子線程以前結束，可是若是主線程處理完其餘的事務後，須要用到子線程的處理結果，也就是主線程須要等待子線程執行完成以後再結束，這個時候就要用到join()方法了。

不加join。

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()+ "主線程運行結束!");

    }

}

輸出結果：
main主線程運行開始!
main主線程運行結束!
B 線程運行開始!
子線程B運行 : 0
A 線程運行開始!
子線程A運行 : 0
子線程B運行 : 1
子線程A運行 : 1
子線程A運行 : 2
子線程A運行 : 3
子線程A運行 : 4
A 線程運行結束!
子線程B運行 : 2
子線程B運行 : 3
子線程B運行 : 4
B 線程運行結束!
發現主線程比子線程早結束

加join

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()+ "主線程運行結束!");

    }

}

運行結果：
main主線程運行開始!
A 線程運行開始!
子線程A運行 : 0
B 線程運行開始!
子線程B運行 : 0
子線程A運行 : 1
子線程B運行 : 1
子線程A運行 : 2
子線程B運行 : 2
子線程A運行 : 3
子線程B運行 : 3
子線程A運行 : 4
子線程B運行 : 4
A 線程運行結束!
主線程必定會等子線程都結束了才結束

③yield():暫停當前正在執行的線程對象，並執行其餘線程。
        Thread.yield()方法做用是：暫停當前正在執行的線程對象，並執行其餘線程。         yield()應該作的是讓當前運行線程回到可運行狀態，以容許具備相同優先級的其餘線程得到運行機會。所以，使用yield()的目的是讓相同優先級的線程之間能適當的輪轉執行。可是，實際中沒法保證yield()達到讓步目的，由於讓步的線程還有可能被線程調度程序再次選中。 結論：yield()從未致使線程轉到等待/睡眠/阻塞狀態。在大多數狀況下，yield()將致使線程從運行狀態轉到可運行狀態，但有可能沒有效果。可看上面的圖。

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();
    }

}

運行結果：

第一種狀況：李四（線程）當執行到30時會CPU時間讓掉，這時張三（線程）搶到CPU時間並執行。

第二種狀況：李四（線程）當執行到30時會CPU時間讓掉，這時李四（線程）搶到CPU時間並執行。

sleep()和yield()的區別
        sleep()和yield()的區別):sleep()使當前線程進入停滯狀態，因此執行sleep()的線程在指定的時間內確定不會被執行；yield()只是使當前線程從新回到可執行狀態，因此執行yield()的線程有可能在進入到可執行狀態後立刻又被執行。
        sleep 方法使當前運行中的線程睡眼一段時間，進入不可運行狀態，這段時間的長短是由程序設定的，yield 方法使當前線程讓出 CPU 佔有權，但讓出的時間是不可設定的。實際上，yield()方法對應了以下操做：先檢測當前是否有相同優先級的線程處於同可運行狀態，若有，則把 CPU  的佔有權交給此線程，不然，繼續運行原來的線程。因此yield()方法稱爲「退讓」，它把運行機會讓給了同等優先級的其餘線程
       另外，sleep 方法容許較低優先級的線程得到運行機會，但 yield()  方法執行時，當前線程仍處在可運行狀態，因此，不可能讓出較低優先級的線程些時得到 CPU 佔有權。在一個運行系統中，若是較高優先級的線程沒有調用 sleep 方法，又沒有受到 I\O 阻塞，那麼，較低優先級線程只能等待全部較高優先級的線程運行結束，纔有機會運行。 

④setPriority(): 更改線程的優先級。

　　　　MIN_PRIORITY = 1
  　　   NORM_PRIORITY = 5
           MAX_PRIORITY = 10

用法：

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

⑤interrupt():中斷某個線程，這種結束方式比較粗暴，若是t線程打開了某個資源還沒來得及關閉也就是run方法尚未執行完就強制結束線程，會致使資源沒法關閉

　　要想結束進程最好的辦法就是用sleep()函數的例子程序裏那樣，在線程類裏面用以個boolean型變量來控制run()方法何時結束，run()方法一結束，該線程也就結束了。

⑥wait()

Obj.wait()，與Obj.notify()必需要與synchronized(Obj)一塊兒使用，也就是wait,與notify是針對已經獲取了Obj鎖進行操做，從語法角度來講就是Obj.wait(),Obj.notify必須在synchronized(Obj){...}語句塊內。從功能上來講wait就是說線程在獲取對象鎖後，主動釋放對象鎖，同時本線程休眠。直到有其它線程調用對象的notify()喚醒該線程，才能繼續獲取對象鎖，並繼續執行。相應的notify()就是對對象鎖的喚醒操做。但有一點須要注意的是notify()調用後，並非立刻就釋放對象鎖的，而是在相應的synchronized(){}語句塊執行結束，自動釋放鎖後，JVM會在wait()對象鎖的線程中隨機選取一線程，賦予其對象鎖，喚醒線程，繼續執行。這樣就提供了在線程間同步、喚醒的操做。Thread.sleep()與Object.wait()兩者均可以暫停當前線程，釋放CPU控制權，主要的區別在於Object.wait()在釋放CPU同時，釋放了對象鎖的控制。

    單單在概念上理解清楚了還不夠，須要在實際的例子中進行測試才能更好的理解。對Object.wait()，Object.notify()的應用最經典的例子，應該是三線程打印ABC的問題了吧，這是一道比較經典的面試題，題目要求以下：

    創建三個線程，A線程打印10次A，B線程打印10次B,C線程打印10次C，要求線程同時運行，交替打印10次ABC。這個問題用Object的wait()，notify()就能夠很方便的解決。代碼以下：

/**
 * 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);
    }
}

輸出結果：

ABCABCABCABCABCABCABCABCABCABC

     先來解釋一下其總體思路，從大的方向上來說，該問題爲三線程間的同步喚醒操做，主要的目的就是ThreadA->ThreadB->ThreadC->ThreadA循環執行三個線程。爲了控制線程執行的順序，那麼就必需要肯定喚醒、等待的順序，因此每個線程必須同時持有兩個對象鎖，才能繼續執行。一個對象鎖是prev，就是前一個線程所持有的對象鎖。還有一個就是自身對象鎖。主要的思想就是，爲了控制執行的順序，必需要先持有prev鎖，也就前一個線程要釋放自身對象鎖，再去申請自身對象鎖，二者兼備時打印，以後首先調用self.notify()釋放自身對象鎖，喚醒下一個等待線程，再調用prev.wait()釋放prev對象鎖，終止當前線程，等待循環結束後再次被喚醒。運行上述代碼，能夠發現三個線程循環打印ABC，共10次。程序運行的主要過程就是A線程最早運行，持有C,A對象鎖，後釋放A,C鎖，喚醒B。線程B等待A鎖，再申請B鎖，後打印B，再釋放B，A鎖，喚醒C，線程C等待B鎖，再申請C鎖，後打印C，再釋放C,B鎖，喚醒A。看起來彷佛沒什麼問題，但若是你仔細想一下，就會發現有問題，就是初始條件，三個線程按照A,B,C的順序來啓動，按照前面的思考，A喚醒B，B喚醒C，C再喚醒A。可是這種假設依賴於JVM中線程調度、執行的順序。
    wait和sleep區別
共同點： 
1. 他們都是在多線程的環境下，均可以在程序的調用處阻塞指定的毫秒數，並返回。 
2. wait()和sleep()均可以經過interrupt()方法 打斷線程的暫停狀態 ，從而使線程馬上拋出InterruptedException。 
   若是線程A但願當即結束線程B，則能夠對線程B對應的Thread實例調用interrupt方法。若是此刻線程B正在wait/sleep /join，則線程B會馬上拋出InterruptedException，在catch() {} 中直接return便可安全地結束線程。 
   須要注意的是，InterruptedException是線程本身從內部拋出的，並非interrupt()方法拋出的。對某一線程調用 interrupt()時，若是該線程正在執行普通的代碼，那麼該線程根本就不會拋出InterruptedException。可是，一旦該線程進入到 wait()/sleep()/join()後，就會馬上拋出InterruptedException 。 
不一樣點： 
1. Thread類的方法：sleep(),yield()等 
   Object的方法：wait()和notify()等 
2. 每一個對象都有一個鎖來控制同步訪問。Synchronized關鍵字能夠和對象的鎖交互，來實現線程的同步。 
   sleep方法沒有釋放鎖，而wait方法釋放了鎖，使得其餘線程可使用同步控制塊或者方法。 
3. wait，notify和notifyAll只能在同步控制方法或者同步控制塊裏面使用，而sleep能夠在任何地方使用 
4. sleep必須捕獲異常，而wait，notify和notifyAll不須要捕獲異常
因此sleep()和wait()方法的最大區別是：
　　　　sleep()睡眠時，保持對象鎖，仍然佔有該鎖；
　　　　而wait()睡眠時，釋放對象鎖。
　　可是wait()和sleep()均可以經過interrupt()方法打斷線程的暫停狀態，從而使線程馬上拋出InterruptedException（但不建議使用該方法）。
sleep（）方法
sleep()使當前線程進入停滯狀態（阻塞當前線程），讓出CUP的使用、目的是不讓當前線程獨自霸佔該進程所獲的CPU資源，以留必定時間給其餘線程執行的機會;
　　 sleep()是Thread類的Static(靜態)的方法；所以他不能改變對象的機鎖，因此當在一個Synchronized塊中調用Sleep()方法是，線程雖然休眠了，可是對象的機鎖並木有被釋放，其餘線程沒法訪問這個對象（即便睡着也持有對象鎖）。
　　在sleep()休眠時間期滿後，該線程不必定會當即執行，這是由於其它線程可能正在運行並且沒有被調度爲放棄執行，除非此線程具備更高的優先級。 
wait（）方法
wait()方法是Object類裏的方法；當一個線程執行到wait()方法時，它就進入到一個和該對象相關的等待池中，同時失去（釋放）了對象的機鎖（暫時失去機鎖，wait(long timeout)超時時間到後還須要返還對象鎖）；其餘線程能夠訪問；
　　wait()使用notify或者notifyAlll或者指定睡眠時間來喚醒當前等待池中的線程。
　　wiat()必須放在synchronized block中，不然會在program runtime時扔出」java.lang.IllegalMonitorStateException「異常。

7、常見線程名詞解釋

主線程：JVM調用程序main()所產生的線程。當前線程：這個是容易混淆的概念。通常指經過Thread.currentThread()來獲取的進程。後臺線程：指爲其餘線程提供服務的線程，也稱爲守護線程。JVM的垃圾回收線程就是一個後臺線程。用戶線程和守護線程的區別在於，是否等待主線程依賴於主線程結束而結束前臺線程：是指接受後臺線程服務的線程，其實前臺後臺線程是聯繫在一塊兒，就像傀儡和幕後操縱者同樣的關係。傀儡是前臺線程、幕後操縱者是後臺線程。由前臺線程建立的線程默認也是前臺線程。能夠經過isDaemon()和setDaemon()方法來判斷和設置一個線程是否爲後臺線程。線程類的一些經常使用方法： 

　　sleep(): 強迫一個線程睡眠Ｎ毫秒。 
　　isAlive(): 判斷一個線程是否存活。 
　　join(): 等待線程終止。 
　　activeCount(): 程序中活躍的線程數。 
　　enumerate(): 枚舉程序中的線程。 
    currentThread(): 獲得當前線程。 
　　isDaemon(): 一個線程是否爲守護線程。 
　　setDaemon(): 設置一個線程爲守護線程。(用戶線程和守護線程的區別在於，是否等待主線程依賴於主線程結束而結束) 
　　setName(): 爲線程設置一個名稱。 
　　wait(): 強迫一個線程等待。 
　　notify(): 通知一個線程繼續運行。 
　　setPriority(): 設置一個線程的優先級。

8、線程同步

一、synchronized關鍵字的做用域有二種： 
1）是某個對象實例內，synchronized aMethod(){}能夠防止多個線程同時訪問這個對象的synchronized方法（若是一個對象有多個synchronized方法，只要一個線程訪問了其中的一個synchronized方法，其它線程不能同時訪問這個對象中任何一個synchronized方法）。這時，不一樣的對象實例的synchronized方法是不相干擾的。也就是說，其它線程照樣能夠同時訪問相同類的另外一個對象實例中的synchronized方法； 
2）是某個類的範圍，synchronized static aStaticMethod{}防止多個線程同時訪問這個類中的synchronized static 方法。它能夠對類的全部對象實例起做用。 

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

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

Java對多線程的支持與同步機制深受你們的喜好，彷佛看起來使用了synchronized關鍵字就能夠輕鬆地解決多線程共享數據同步問題。到底如何？――還得對synchronized關鍵字的做用進行深刻了解纔可定論。

總的說來，synchronized關鍵字能夠做爲函數的修飾符，也可做爲函數內的語句，也就是平時說的同步方法和同步語句塊。若是再細的分類，synchronized可做用於instance變量、object reference（對象引用）、static函數和class literals(類名稱字面常量)身上。

在進一步闡述以前，咱們須要明確幾點：

A．不管synchronized關鍵字加在方法上仍是對象上，它取得的鎖都是對象，而不是把一段代碼或函數看成鎖――並且同步方法極可能還會被其餘線程的對象訪問。

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

C．實現同步是要很大的系統開銷做爲代價的，甚至可能形成死鎖，因此儘可能避免無謂的同步控制。

接着來討論synchronized用到不一樣地方對代碼產生的影響：

 

假設P一、P2是同一個類的不一樣對象，這個類中定義瞭如下幾種狀況的同步塊或同步方法，P一、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。

一、線程同步的目的是爲了保護多個線程反問一個資源時對資源的破壞。 二、線程同步方法是經過鎖來實現，每一個對象都有切僅有一個鎖，這個鎖與一個特定的對象關聯，線程一旦獲取了對象鎖，其餘訪問該對象的線程就沒法再訪問該對象的其餘非同步方法。 三、對於靜態同步方法，鎖是針對這個類的，鎖對象是該類的Class對象。靜態和非靜態方法的鎖互不干預。一個線程得到鎖，當在一個同步方法中訪問另外對象上的同步方法時，會獲取這兩個對象鎖。 四、對於同步，要時刻清醒在哪一個對象上同步，這是關鍵。 五、編寫線程安全的類，須要時刻注意對多個線程競爭訪問資源的邏輯和安全作出正確的判斷，對「原子」操做作出分析，並保證原子操做期間別的線程沒法訪問競爭資源。 六、當多個線程等待一個對象鎖時，沒有獲取到鎖的線程將發生阻塞。 七、死鎖是線程間相互等待鎖鎖形成的，在實際中發生的機率很是的小。真讓你寫個死鎖程序，不必定好使，呵呵。可是，一旦程序發生死鎖，程序將死掉。

9、線程數據傳遞

在傳統的同步開發模式下，當咱們調用一個函數時，經過這個函數的參數將數據傳入，並經過這個函數的返回值來返回最終的計算結果。但在多線程的異步開發模式下，數據的傳遞和返回和同步開發模式有很大的區別。因爲線程的運行和結束是不可預料的，所以，在傳遞和返回數據時就沒法象函數同樣經過函數參數和return語句來返回數據。

9.一、經過構造方法傳遞數據 
在建立線程時，必需要創建一個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(); 
    } 
}

因爲這種方法是在建立線程對象的同時傳遞數據的，所以，在線程運行以前這些數據就就已經到位了，這樣就不會形成數據在線程運行後才傳入的現象。若是要傳遞更復雜的數據，可使用集合、類等數據結構。使用構造方法來傳遞數據雖然比較安全，但若是要傳遞的數據比較多時，就會形成不少不便。因爲Java沒有默認參數，要想實現相似默認參數的效果，就得使用重載，這樣不但使構造方法自己過於複雜，又會使構造方法在數量上大增。所以，要想避免這種狀況，就得經過類方法或類變量來傳遞數據。 

9.二、經過變量和方法傳遞數據 
向對象中傳入數據通常有兩次機會，第一次機會是在創建對象時經過構造方法將數據傳入，另一次機會就是在類中定義一系列的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(); 
	} 
}

9.三、經過回調函數傳遞數據 

上面討論的兩種向線程中傳遞數據的方法是最經常使用的。但這兩種方法都是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();
    }
}