林炳文Evankaka原創(chuàng)作品。轉(zhuǎn)載請注明出處http://blog.csdn.net/evankaka

寫在前面的話：此文只能說是java多線程的一個入門，其實(shí)Java里頭線程完全可以寫一本書了绑蔫，但是如果最基本的你都學(xué)掌握好徒蟆，又怎么能更上一個臺階呢？如果你覺得此文很簡單作谚，那推薦你看看Java并發(fā)包的的線程池（Java并發(fā)編程與技術(shù)內(nèi)幕:線程池深入理解），或者看這個專欄：Java并發(fā)編程與技術(shù)內(nèi)幕庵芭。你將會對Java里頭的高并發(fā)場景下的線程有更加深刻的理解妹懒。

目錄

一擴(kuò)展javalangThread類
二實(shí)現(xiàn)javalangRunnable接口
三Thread和Runnable的區(qū)別
四線程狀態(tài)轉(zhuǎn)換
五線程調(diào)度
六常用函數(shù)說明
使用方式
為什么要用join方法
七常見線程名詞解釋
八線程同步
九線程數(shù)據(jù)傳遞

本文主要講了java中多線程的使用方法、線程同步双吆、線程數(shù)據(jù)傳遞眨唬、線程狀態(tài)及相應(yīng)的一些線程函數(shù)用法、概述等好乐。在這之前匾竿，首先讓我們來了解下在操作系統(tǒng)中進(jìn)程和線程的區(qū)別：

進(jìn)程：每個進(jìn)程都有獨(dú)立的代碼和數(shù)據(jù)空間（進(jìn)程上下文），進(jìn)程間的切換會有較大的開銷蔚万，一個進(jìn)程包含1--n個線程岭妖。（進(jìn)程是資源分配的最小單位）
　　線程：同一類線程共享代碼和數(shù)據(jù)空間，每個線程有獨(dú)立的運(yùn)行棧和程序計數(shù)器(PC)反璃，線程切換開銷小昵慌。（線程是cpu調(diào)度的最小單位）
　　線程和進(jìn)程一樣分為五個階段：創(chuàng)建、就緒淮蜈、運(yùn)行斋攀、阻塞、終止梧田。

多進(jìn)程是指操作系統(tǒng)能同時運(yùn)行多個任務(wù)（程序）淳蔼。

多線程是指在同一程序中有多個順序流在執(zhí)行侧蘸。

在java中要想實(shí)現(xiàn)多線程，有兩種手段鹉梨，一種是繼續(xù)Thread類闺魏，另外一種是實(shí)現(xiàn)Runable接口.(其實(shí)準(zhǔn)確來講，應(yīng)該有三種俯画，還有一種是實(shí)現(xiàn)Callable接口析桥，并與Future、線程池結(jié)合使用艰垂，此文這里不講這個泡仗，有興趣看這里Java并發(fā)編程與技術(shù)內(nèi)幕:Callable、Future猜憎、FutureTask娩怎、CompletionService )

一、擴(kuò)展java.lang.Thread類

這里繼承Thread類的方法是比較常用的一種胰柑，如果說你只是想起一條線程截亦。沒有什么其它特殊的要求，那么可以使用Thread.（筆者推薦使用Runable柬讨，后頭會說明為什么）崩瓤。下面來看一個簡單的實(shí)例

package com.multithread.learning;
/**
 *@functon 多線程學(xué)習(xí)
 *@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 + "運(yùn)行  :  " + 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運(yùn)行 : 0
B運(yùn)行 : 0
A運(yùn)行 : 1
A運(yùn)行 : 2
A運(yùn)行 : 3
A運(yùn)行 : 4
B運(yùn)行 : 1
B運(yùn)行 : 2
B運(yùn)行 : 3
B運(yùn)行 : 4

再運(yùn)行一下：

A運(yùn)行 : 0
B運(yùn)行 : 0
B運(yùn)行 : 1
B運(yùn)行 : 2
B運(yùn)行 : 3
B運(yùn)行 : 4
A運(yùn)行 : 1
A運(yùn)行 : 2
A運(yùn)行 : 3
A運(yùn)行 : 4

說明：
程序啟動運(yùn)行main時候，java虛擬機(jī)啟動一個進(jìn)程踩官，主線程main在main()調(diào)用時候被創(chuàng)建却桶。隨著調(diào)用MitiSay的兩個對象的start方法，另外兩個線程也啟動了蔗牡，這樣颖系，整個應(yīng)用就在多線程下運(yùn)行。

注意：start()方法的調(diào)用后并不是立即執(zhí)行多線程代碼辩越，而是使得該線程變?yōu)榭蛇\(yùn)行態(tài)（Runnable）嘁扼，什么時候運(yùn)行是由操作系統(tǒng)決定的。
從程序運(yùn)行的結(jié)果可以發(fā)現(xiàn)黔攒，多線程程序是亂序執(zhí)行趁啸。因此绕辖，只有亂序執(zhí)行的代碼才有必要設(shè)計為多線程芍秆。
Thread.sleep()方法調(diào)用目的是不讓當(dāng)前線程獨(dú)自霸占該進(jìn)程所獲取的CPU資源，以留出一定時間給其他線程執(zhí)行的機(jī)會观堂。
實(shí)際上所有的多線程代碼執(zhí)行順序都是不確定的姑丑，每次執(zhí)行的結(jié)果都是隨機(jī)的蛤签。
但是start方法重復(fù)調(diào)用的話，會出現(xiàn)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運(yùn)行 : 0
A運(yùn)行 : 1
A運(yùn)行 : 2
A運(yùn)行 : 3
A運(yùn)行 : 4

二震肮、實(shí)現(xiàn)java.lang.Runnable接口

采用Runnable也是非常常見的一種称龙，我們只需要重寫run方法即可。下面也來看個實(shí)例戳晌。

/**
 *@functon 多線程學(xué)習(xí)
 *@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 + "運(yùn)行  :  " + 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運(yùn)行 : 0
D運(yùn)行 : 0
D運(yùn)行 : 1
C運(yùn)行 : 1
D運(yùn)行 : 2
C運(yùn)行 : 2
D運(yùn)行 : 3
C運(yùn)行 : 3
D運(yùn)行 : 4
C運(yùn)行 : 4

說明：
Thread2類通過實(shí)現(xiàn)Runnable接口鲫尊，使得該類有了多線程類的特征。run（）方法是多線程程序的一個約定沦偎。所有的多線程代碼都在run方法里面疫向。Thread類實(shí)際上也是實(shí)現(xiàn)了Runnable接口的類。
在啟動的多線程的時候豪嚎，需要先通過Thread類的構(gòu)造方法Thread(Runnable target) 構(gòu)造出對象搔驼，然后調(diào)用Thread對象的start()方法來運(yùn)行多線程代碼。
實(shí)際上所有的多線程代碼都是通過運(yùn)行Thread的start()方法來運(yùn)行的侈询。因此舌涨，不管是擴(kuò)展Thread類還是實(shí)現(xiàn)Runnable接口來實(shí)現(xiàn)多線程，最終還是通過Thread的對象的API來控制線程的扔字，熟悉Thread類的API是進(jìn)行多線程編程的基礎(chǔ)囊嘉。

三、Thread和Runnable的區(qū)別

如果一個類繼承Thread革为，則不適合資源共享扭粱。但是如果實(shí)現(xiàn)了Runable接口的話，則很容易的實(shí)現(xiàn)資源共享篷角。

總結(jié)：

實(shí)現(xiàn)Runnable接口比繼承Thread類所具有的優(yōu)勢：

1）：適合多個相同的程序代碼的線程去處理同一個資源
2）：可以避免java中的單繼承的限制
3）：增加程序的健壯性焊刹，代碼可以被多個線程共享，代碼和數(shù)據(jù)獨(dú)立
4）：線程池只能放入實(shí)現(xiàn)Runable或callable類線程恳蹲，不能直接放入繼承Thread的類

提醒一下大家：main方法其實(shí)也是一個線程。在java中所以的線程都是同時啟動的俩滥，至于什么時候嘉蕾，哪個先執(zhí)行，完全看誰先得到CPU的資源霜旧。

在java中错忱，每次程序運(yùn)行至少啟動2個線程。一個是main線程挂据，一個是垃圾收集線程以清。因?yàn)槊慨?dāng)使用java命令執(zhí)行一個類的時候，實(shí)際上都會啟動一個ＪＶＭ崎逃，每一個ｊＶＭ實(shí)習(xí)在就是在操作系統(tǒng)中啟動了一個進(jìn)程掷倔。

四、線程狀態(tài)轉(zhuǎn)換

下面的這個圖非常重要个绍！你如果看懂了這個圖勒葱，那么對于多線程的理解將會更加深刻浪汪！

1、新建狀態(tài)（New）：新創(chuàng)建了一個線程對象凛虽。
2死遭、就緒狀態(tài)（Runnable）：線程對象創(chuàng)建后，其他線程調(diào)用了該對象的start()方法凯旋。該狀態(tài)的線程位于可運(yùn)行線程池中呀潭，變得可運(yùn)行，等待獲取CPU的使用權(quán)至非。
3钠署、運(yùn)行狀態(tài)（Running）：就緒狀態(tài)的線程獲取了CPU，執(zhí)行程序代碼睡蟋。
4踏幻、阻塞狀態(tài)（Blocked）：阻塞狀態(tài)是線程因?yàn)槟撤N原因放棄CPU使用權(quán)，暫時停止運(yùn)行戳杀。直到線程進(jìn)入就緒狀態(tài)该面，才有機(jī)會轉(zhuǎn)到運(yùn)行狀態(tài)。阻塞的情況分三種：
（一）信卡、等待阻塞：運(yùn)行的線程執(zhí)行wait()方法隔缀，JVM會把該線程放入等待池中。(wait會釋放持有的鎖)
（二）傍菇、同步阻塞：運(yùn)行的線程在獲取對象的同步鎖時猾瘸，若該同步鎖被別的線程占用，則JVM會把該線程放入鎖池中丢习。
（三）牵触、其他阻塞：運(yùn)行的線程執(zhí)行sleep()或join()方法，或者發(fā)出了I/O請求時咐低，JVM會把該線程置為阻塞狀態(tài)揽思。當(dāng)sleep()狀態(tài)超時、join()等待線程終止或者超時见擦、或者I/O處理完畢時钉汗，線程重新轉(zhuǎn)入就緒狀態(tài)。（注意,sleep是不會釋放持有的鎖）
5鲤屡、死亡狀態(tài)（Dead）：線程執(zhí)行完了或者因異常退出了run()方法损痰，該線程結(jié)束生命周期。

五酒来、線程調(diào)度

線程的調(diào)度

1卢未、調(diào)整線程優(yōu)先級：Java線程有優(yōu)先級，優(yōu)先級高的線程會獲得較多的運(yùn)行機(jī)會役首。

Java線程的優(yōu)先級用整數(shù)表示尝丐，取值范圍是1~10显拜，Thread類有以下三個靜態(tài)常量：
static int MAX_PRIORITY
線程可以具有的最高優(yōu)先級，取值為10爹袁。
static int MIN_PRIORITY
線程可以具有的最低優(yōu)先級远荠，取值為1。
static int NORM_PRIORITY
分配給線程的默認(rèn)優(yōu)先級失息，取值為5譬淳。

Thread類的setPriority()和getPriority()方法分別用來設(shè)置和獲取線程的優(yōu)先級。
每個線程都有默認(rèn)的優(yōu)先級盹兢。主線程的默認(rèn)優(yōu)先級為Thread.NORM_PRIORITY邻梆。
線程的優(yōu)先級有繼承關(guān)系，比如A線程中創(chuàng)建了B線程绎秒，那么B將和A具有相同的優(yōu)先級浦妄。
JVM提供了10個線程優(yōu)先級，但與常見的操作系統(tǒng)都不能很好的映射见芹。如果希望程序能移植到各個操作系統(tǒng)中剂娄，應(yīng)該僅僅使用Thread類有以下三個靜態(tài)常量作為優(yōu)先級，這樣能保證同樣的優(yōu)先級采用了同樣的調(diào)度方式玄呛。

2阅懦、線程睡眠：Thread.sleep(long millis)方法，使線程轉(zhuǎn)到阻塞狀態(tài)徘铝。millis參數(shù)設(shè)定睡眠的時間耳胎，以毫秒為單位。當(dāng)睡眠結(jié)束后惕它，就轉(zhuǎn)為就緒（Runnable）狀態(tài)怕午。sleep()平臺移植性好。

3淹魄、線程等待：Object類中的wait()方法诗轻，導(dǎo)致當(dāng)前的線程等待，直到其他線程調(diào)用此對象的 notify() 方法或 notifyAll() 喚醒方法揭北。這個兩個喚醒方法也是Object類中的方法，行為等價于調(diào)用 wait(0) 一樣吏颖。

4搔体、線程讓步：Thread.yield() 方法，暫停當(dāng)前正在執(zhí)行的線程對象半醉，把執(zhí)行機(jī)會讓給相同或者更高優(yōu)先級的線程疚俱。

5、線程加入：join()方法缩多，等待其他線程終止呆奕。在當(dāng)前線程中調(diào)用另一個線程的join()方法养晋，則當(dāng)前線程轉(zhuǎn)入阻塞狀態(tài)，直到另一個進(jìn)程運(yùn)行結(jié)束梁钾，當(dāng)前線程再由阻塞轉(zhuǎn)為就緒狀態(tài)绳泉。

6、線程喚醒：Object類中的notify()方法姆泻，喚醒在此對象監(jiān)視器上等待的單個線程零酪。如果所有線程都在此對象上等待，則會選擇喚醒其中一個線程拇勃。選擇是任意性的四苇，并在對實(shí)現(xiàn)做出決定時發(fā)生。線程通過調(diào)用其中一個 wait 方法方咆，在對象的監(jiān)視器上等待月腋。 直到當(dāng)前的線程放棄此對象上的鎖定，才能繼續(xù)執(zhí)行被喚醒的線程瓣赂。被喚醒的線程將以常規(guī)方式與在該對象上主動同步的其他所有線程進(jìn)行競爭榆骚；例如，喚醒的線程在作為鎖定此對象的下一個線程方面沒有可靠的特權(quán)或劣勢钩述。類似的方法還有一個notifyAll()寨躁，喚醒在此對象監(jiān)視器上等待的所有線程。
注意：Thread中suspend()和resume()兩個方法在JDK1.5中已經(jīng)廢除牙勘，不再介紹职恳。因?yàn)橛兴梨i傾向。

六方面、常用函數(shù)說明

①sleep(long millis): 在指定的毫秒數(shù)內(nèi)讓當(dāng)前正在執(zhí)行的線程休眠（暫停執(zhí)行）

②join():指等待t線程終止放钦。
使用方式。
join是Thread類的一個方法恭金，啟動線程后直接調(diào)用操禀，即join()的作用是：“等待該線程終止”，這里需要理解的就是該線程是指的主線程等待子線程的終止横腿。也就是在子線程調(diào)用了join()方法后面的代碼颓屑，只有等到子線程結(jié)束了才能執(zhí)行。

Thread t = new AThread(); t.start(); t.join();
為什么要用join()方法
在很多情況下耿焊，主線程生成并起動了子線程揪惦，如果子線程里要進(jìn)行大量的耗時的運(yùn)算，主線程往往將于子線程之前結(jié)束罗侯，但是如果主線程處理完其他的事務(wù)后器腋，需要用到子線程的處理結(jié)果，也就是主線程需要等待子線程執(zhí)行完成之后再結(jié)束，這個時候就要用到j(luò)oin()方法了纫塌。

不加join诊县。

/**
 *@functon 多線程學(xué)習(xí),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() + " 線程運(yùn)行開始!");
        for (int i = 0; i < 5; i++) {
            System.out.println("子線程"+name + "運(yùn)行 : " + i);
            try {
                sleep((int) Math.random() * 10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName() + " 線程運(yùn)行結(jié)束!");
    }
}
 
public class Main {
 
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName()+"主線程運(yùn)行開始!");
        Thread1 mTh1=new Thread1("A");
        Thread1 mTh2=new Thread1("B");
        mTh1.start();
        mTh2.start();
        System.out.println(Thread.currentThread().getName()+ "主線程運(yùn)行結(jié)束!");
 
    }
 
}

輸出結(jié)果：
main主線程運(yùn)行開始!
main主線程運(yùn)行結(jié)束!
B 線程運(yùn)行開始!
子線程B運(yùn)行 : 0
A 線程運(yùn)行開始!
子線程A運(yùn)行 : 0
子線程B運(yùn)行 : 1
子線程A運(yùn)行 : 1
子線程A運(yùn)行 : 2
子線程A運(yùn)行 : 3
子線程A運(yùn)行 : 4
A 線程運(yùn)行結(jié)束!
子線程B運(yùn)行 : 2
子線程B運(yùn)行 : 3
子線程B運(yùn)行 : 4
B 線程運(yùn)行結(jié)束!
發(fā)現(xiàn)主線程比子線程早結(jié)束

加join

public class Main {
 
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName()+"主線程運(yùn)行開始!");
        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()+ "主線程運(yùn)行結(jié)束!");
 
    }
 
}

運(yùn)行結(jié)果：
main主線程運(yùn)行開始!
A 線程運(yùn)行開始!
子線程A運(yùn)行 : 0
B 線程運(yùn)行開始!
子線程B運(yùn)行 : 0
子線程A運(yùn)行 : 1
子線程B運(yùn)行 : 1
子線程A運(yùn)行 : 2
子線程B運(yùn)行 : 2
子線程A運(yùn)行 : 3
子線程B運(yùn)行 : 3
子線程A運(yùn)行 : 4
子線程B運(yùn)行 : 4
A 線程運(yùn)行結(jié)束!
主線程一定會等子線程都結(jié)束了才結(jié)束

③yield():暫停當(dāng)前正在執(zhí)行的線程對象，并執(zhí)行其他線程措左。
Thread.yield()方法作用是：暫停當(dāng)前正在執(zhí)行的線程對象依痊，并執(zhí)行其他線程。
yield()應(yīng)該做的是讓當(dāng)前運(yùn)行線程回到可運(yùn)行狀態(tài)媳荒，以允許具有相同優(yōu)先級的其他線程獲得運(yùn)行機(jī)會抗悍。因此，使用yield()的目的是讓相同優(yōu)先級的線程之間能適當(dāng)?shù)妮嗈D(zhuǎn)執(zhí)行钳枕。但是缴渊，實(shí)際中無法保證yield()達(dá)到讓步目的，因?yàn)樽尣降木€程還有可能被線程調(diào)度程序再次選中鱼炒。

結(jié)論：yield()從未導(dǎo)致線程轉(zhuǎn)到等待/睡眠/阻塞狀態(tài)衔沼。在大多數(shù)情況下，yield()將導(dǎo)致線程從運(yùn)行狀態(tài)轉(zhuǎn)到可運(yùn)行狀態(tài)昔瞧，但有可能沒有效果指蚁。可看上面的圖自晰。

/**
 *@functon 多線程學(xué)習(xí) 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);
            // 當(dāng)i為30時凝化，該線程就會把CPU時間讓掉，讓其他或者自己的線程執(zhí)行（也就是誰先搶到誰執(zhí)行）
            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();
    }
 
}

運(yùn)行結(jié)果：
第一種情況：李四（線程）當(dāng)執(zhí)行到30時會CPU時間讓掉酬荞，這時張三（線程）搶到CPU時間并執(zhí)行搓劫。

第二種情況：李四（線程）當(dāng)執(zhí)行到30時會CPU時間讓掉，這時李四（線程）搶到CPU時間并執(zhí)行混巧。

sleep()和yield()的區(qū)別
sleep()和yield()的區(qū)別):sleep()使當(dāng)前線程進(jìn)入停滯狀態(tài)枪向，所以執(zhí)行sleep()的線程在指定的時間內(nèi)肯定不會被執(zhí)行；yield()只是使當(dāng)前線程重新回到可執(zhí)行狀態(tài)咧党，所以執(zhí)行yield()的線程有可能在進(jìn)入到可執(zhí)行狀態(tài)后馬上又被執(zhí)行秘蛔。
sleep 方法使當(dāng)前運(yùn)行中的線程睡眼一段時間，進(jìn)入不可運(yùn)行狀態(tài)傍衡，這段時間的長短是由程序設(shè)定的深员，yield 方法使當(dāng)前線程讓出 CPU 占有權(quán)，但讓出的時間是不可設(shè)定的蛙埂。實(shí)際上辨液，yield()方法對應(yīng)了如下操作：先檢測當(dāng)前是否有相同優(yōu)先級的線程處于同可運(yùn)行狀態(tài)，如有箱残，則把 CPU 的占有權(quán)交給此線程，否則，繼續(xù)運(yùn)行原來的線程被辑。所以yield()方法稱為“退讓”燎悍，它把運(yùn)行機(jī)會讓給了同等優(yōu)先級的其他線程
另外，sleep 方法允許較低優(yōu)先級的線程獲得運(yùn)行機(jī)會盼理，但 yield() 方法執(zhí)行時谈山，當(dāng)前線程仍處在可運(yùn)行狀態(tài)，所以宏怔，不可能讓出較低優(yōu)先級的線程些時獲得 CPU 占有權(quán)奏路。在一個運(yùn)行系統(tǒng)中，如果較高優(yōu)先級的線程沒有調(diào)用 sleep 方法臊诊，又沒有受到 I\O 阻塞鸽粉，那么，較低優(yōu)先級線程只能等待所有較高優(yōu)先級的線程運(yùn)行結(jié)束抓艳，才有機(jī)會運(yùn)行触机。

④setPriority(): 更改線程的優(yōu)先級。
　　　　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():不要以為它是中斷某個線程玷或！它只是線線程發(fā)送一個中斷信號儡首，讓線程在無限等待時（如死鎖時）能拋出拋出，從而結(jié)束線程偏友，但是如果你吃掉了這個異常蔬胯，那么這個線程還是不會中斷的！
⑥wait()

Obj.wait()位他，與Obj.notify()必須要與synchronized(Obj)一起使用氛濒，也就是wait,與notify是針對已經(jīng)獲取了Obj鎖進(jìn)行操作，從語法角度來說就是Obj.wait(),Obj.notify必須在synchronized(Obj){...}語句塊內(nèi)棱诱。從功能上來說wait就是說線程在獲取對象鎖后泼橘，主動釋放對象鎖，同時本線程休眠迈勋。直到有其它線程調(diào)用對象的notify()喚醒該線程炬灭，才能繼續(xù)獲取對象鎖，并繼續(xù)執(zhí)行靡菇。相應(yīng)的notify()就是對對象鎖的喚醒操作重归。但有一點(diǎn)需要注意的是notify()調(diào)用后，并不是馬上就釋放對象鎖的厦凤，而是在相應(yīng)的synchronized(){}語句塊執(zhí)行結(jié)束鼻吮，自動釋放鎖后，JVM會在wait()對象鎖的線程中隨機(jī)選取一線程较鼓，賦予其對象鎖椎木，喚醒線程违柏，繼續(xù)執(zhí)行。這樣就提供了在線程間同步香椎、喚醒的操作漱竖。Thread.sleep()與Object.wait()二者都可以暫停當(dāng)前線程，釋放CPU控制權(quán)畜伐，主要的區(qū)別在于Object.wait()在釋放CPU同時馍惹，釋放了對象鎖的控制。

單單在概念上理解清楚了還不夠玛界，需要在實(shí)際的例子中進(jìn)行測試才能更好的理解万矾。對Object.wait()，Object.notify()的應(yīng)用最經(jīng)典的例子慎框，應(yīng)該是三線程打印ABC的問題了吧良狈，這是一道比較經(jīng)典的面試題，題目要求如下：

建立三個線程鲤脏，A線程打印10次A们颜，B線程打印10次B,C線程打印10次C，要求線程同時運(yùn)行猎醇，交替打印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執(zhí)行
        new Thread(pb).start();
        Thread.sleep(100);  
        new Thread(pc).start();   
        Thread.sleep(100);  
        }   
}  

輸出結(jié)果：
ABCABCABCABCABCABCABCABCABCABC
先來解釋一下其整體思路沦疾，從大的方向上來講称近，該問題為三線程間的同步喚醒操作，主要的目的就是ThreadA->ThreadB->ThreadC->ThreadA循環(huán)執(zhí)行三個線程哮塞。為了控制線程執(zhí)行的順序刨秆，那么就必須要確定喚醒、等待的順序忆畅，所以每一個線程必須同時持有兩個對象鎖衡未，才能繼續(xù)執(zhí)行。一個對象鎖是prev家凯，就是前一個線程所持有的對象鎖缓醋。還有一個就是自身對象鎖。主要的思想就是绊诲，為了控制執(zhí)行的順序送粱，必須要先持有prev鎖，也就前一個線程要釋放自身對象鎖掂之，再去申請自身對象鎖抗俄，兩者兼?zhèn)鋾r打印脆丁，之后首先調(diào)用self.notify()釋放自身對象鎖，喚醒下一個等待線程橄镜，再調(diào)用prev.wait()釋放prev對象鎖偎快，終止當(dāng)前線程，等待循環(huán)結(jié)束后再次被喚醒洽胶。運(yùn)行上述代碼，可以發(fā)現(xiàn)三個線程循環(huán)打印ABC裆馒，共10次姊氓。程序運(yùn)行的主要過程就是A線程最先運(yùn)行，持有C,A對象鎖喷好，后釋放A,C鎖翔横，喚醒B。線程B等待A鎖梗搅，再申請B鎖禾唁，后打印B，再釋放B无切，A鎖荡短，喚醒C，線程C等待B鎖哆键，再申請C鎖掘托，后打印C，再釋放C,B鎖籍嘹，喚醒A闪盔。看起來似乎沒什么問題辱士，但如果你仔細(xì)想一下泪掀，就會發(fā)現(xiàn)有問題，就是初始條件颂碘，三個線程按照A,B,C的順序來啟動异赫，按照前面的思考，A喚醒B凭涂，B喚醒C祝辣，C再喚醒A。但是這種假設(shè)依賴于JVM中線程調(diào)度切油、執(zhí)行的順序蝙斜。
wait和sleep區(qū)別
共同點(diǎn)：

1. 他們都是在多線程的環(huán)境下，都可以在程序的調(diào)用處阻塞指定的毫秒數(shù)澎胡，并返回孕荠。
2. wait()和sleep()都可以通過interrupt()方法 打斷線程的暫停狀態(tài) 娩鹉，從而使線程立刻拋出InterruptedException。
   如果線程A希望立即結(jié)束線程B稚伍，則可以對線程B對應(yīng)的Thread實(shí)例調(diào)用interrupt方法弯予。如果此刻線程B正在wait/sleep /join，則線程B會立刻拋出InterruptedException个曙，在catch() {} 中直接return即可安全地結(jié)束線程锈嫩。
   需要注意的是，InterruptedException是線程自己從內(nèi)部拋出的垦搬，并不是interrupt()方法拋出的呼寸。對某一線程調(diào)用 interrupt()時，如果該線程正在執(zhí)行普通的代碼猴贰，那么該線程根本就不會拋出InterruptedException对雪。但是，一旦該線程進(jìn)入到 wait()/sleep()/join()后米绕，就會立刻拋出InterruptedException 瑟捣。
   不同點(diǎn)：
3. Thread類的方法：sleep(),yield()等
   Object的方法：wait()和notify()等
4. 每個對象都有一個鎖來控制同步訪問。Synchronized關(guān)鍵字可以和對象的鎖交互栅干，來實(shí)現(xiàn)線程的同步迈套。
   sleep方法沒有釋放鎖，而wait方法釋放了鎖非驮，使得其他線程可以使用同步控制塊或者方法交汤。
5. wait，notify和notifyAll只能在同步控制方法或者同步控制塊里面使用劫笙，而sleep可以在任何地方使用
   所以sleep()和wait()方法的最大區(qū)別是：
   　　　　sleep()睡眠時芙扎，保持對象鎖，仍然占有該鎖填大；
   　　　　而wait()睡眠時戒洼，釋放對象鎖。
   　　但是wait()和sleep()都可以通過interrupt()方法打斷線程的暫停狀態(tài)允华，從而使線程立刻拋出InterruptedException（但不建議使用該方法）圈浇。
   sleep（）方法
   sleep()使當(dāng)前線程進(jìn)入停滯狀態(tài)（阻塞當(dāng)前線程），讓出CUP的使用靴寂、目的是不讓當(dāng)前線程獨(dú)自霸占該進(jìn)程所獲的CPU資源磷蜀，以留一定時間給其他線程執(zhí)行的機(jī)會;
   　　 sleep()是Thread類的Static(靜態(tài))的方法；因此他不能改變對象的機(jī)鎖百炬，所以當(dāng)在一個Synchronized塊中調(diào)用Sleep()方法是褐隆，線程雖然休眠了，但是對象的機(jī)鎖并木有被釋放剖踊，其他線程無法訪問這個對象（即使睡著也持有對象鎖）庶弃。
   　　在sleep()休眠時間期滿后衫贬，該線程不一定會立即執(zhí)行，這是因?yàn)槠渌€程可能正在運(yùn)行而且沒有被調(diào)度為放棄執(zhí)行歇攻，除非此線程具有更高的優(yōu)先級固惯。
   wait（）方法
   wait()方法是Object類里的方法；當(dāng)一個線程執(zhí)行到wait()方法時缴守，它就進(jìn)入到一個和該對象相關(guān)的等待池中葬毫，同時失去（釋放）了對象的機(jī)鎖（暫時失去機(jī)鎖，wait(long timeout)超時時間到后還需要返還對象鎖）屡穗；其他線程可以訪問供常；
   　　wait()使用notify或者notifyAlll或者指定睡眠時間來喚醒當(dāng)前等待池中的線程。
   　　wiat()必須放在synchronized block中鸡捐，否則會在program runtime時扔出”java.lang.IllegalMonitorStateException“異常。
   七麻裁、常見線程名詞解釋
   主線程：JVM調(diào)用程序main()所產(chǎn)生的線程箍镜。
   當(dāng)前線程：這個是容易混淆的概念。一般指通過Thread.currentThread()來獲取的進(jìn)程煎源。
   后臺線程：指為其他線程提供服務(wù)的線程色迂，也稱為守護(hù)線程。JVM的垃圾回收線程就是一個后臺線程手销。用戶線程和守護(hù)線程的區(qū)別在于歇僧，是否等待主線程依賴于主線程結(jié)束而結(jié)束
   前臺線程：是指接受后臺線程服務(wù)的線程，其實(shí)前臺后臺線程是聯(lián)系在一起锋拖，就像傀儡和幕后操縱者一樣的關(guān)系诈悍。傀儡是前臺線程兽埃、幕后操縱者是后臺線程侥钳。由前臺線程創(chuàng)建的線程默認(rèn)也是前臺線程”恚可以通過isDaemon()和setDaemon()方法來判斷和設(shè)置一個線程是否為后臺線程舷夺。
   線程類的一些常用方法：

sleep(): 強(qiáng)迫一個線程睡眠Ｎ毫秒。
　　isAlive(): 判斷一個線程是否存活售貌。
　　join(): 等待線程終止给猾。
　　activeCount(): 程序中活躍的線程數(shù)。
　　enumerate(): 枚舉程序中的線程颂跨。
currentThread(): 得到當(dāng)前線程敢伸。
　　isDaemon(): 一個線程是否為守護(hù)線程。
　　setDaemon(): 設(shè)置一個線程為守護(hù)線程毫捣。(用戶線程和守護(hù)線程的區(qū)別在于详拙，是否等待主線程依賴于主線程結(jié)束而結(jié)束)
　　setName(): 為線程設(shè)置一個名稱帝际。
　　wait(): 強(qiáng)迫一個線程等待。
　　notify(): 通知一個線程繼續(xù)運(yùn)行饶辙。
　　setPriority(): 設(shè)置一個線程的優(yōu)先級蹲诀。
八、線程同步
1弃揽、synchronized關(guān)鍵字的作用域有二種：
1）是某個對象實(shí)例內(nèi)脯爪，synchronized aMethod(){}可以防止多個線程同時訪問這個對象的synchronized方法（如果一個對象有多個synchronized方法，只要一個線程訪問了其中的一個synchronized方法矿微，其它線程不能同時訪問這個對象中任何一個synchronized方法）痕慢。這時，不同的對象實(shí)例的synchronized方法是不相干擾的涌矢。也就是說掖举，其它線程照樣可以同時訪問相同類的另一個對象實(shí)例中的synchronized方法；
2）是某個類的范圍娜庇，synchronized static aStaticMethod{}防止多個線程同時訪問這個類中的synchronized static 方法塔次。它可以對類的所有對象實(shí)例起作用。

2名秀、除了方法前用synchronized關(guān)鍵字励负，synchronized關(guān)鍵字還可以用于方法中的某個區(qū)塊中，表示只對這個區(qū)塊的資源實(shí)行互斥訪問匕得。用法是: synchronized(this){/區(qū)塊/}继榆，它的作用域是當(dāng)前對象；

3汁掠、synchronized關(guān)鍵字是不能繼承的略吨，也就是說，基類的方法synchronized f(){} 在繼承類中并不自動是synchronized f(){}调塌，而是變成了f(){}晋南。繼承類需要你顯式的指定它的某個方法為synchronized方法；

Java對多線程的支持與同步機(jī)制深受大家的喜愛羔砾，似乎看起來使用了synchronized關(guān)鍵字就可以輕松地解決多線程共享數(shù)據(jù)同步問題负间。到底如何？――還得對synchronized關(guān)鍵字的作用進(jìn)行深入了解才可定論姜凄。

總的說來政溃，synchronized關(guān)鍵字可以作為函數(shù)的修飾符，也可作為函數(shù)內(nèi)的語句态秧，也就是平時說的同步方法和同步語句塊董虱。如果再細(xì)的分類，synchronized可作用于instance變量、object reference（對象引用）愤诱、static函數(shù)和class literals(類名稱字面常量)身上云头。

在進(jìn)一步闡述之前，我們需要明確幾點(diǎn)：

A．無論synchronized關(guān)鍵字加在方法上還是對象上淫半，它取得的鎖都是對象溃槐，而不是把一段代碼或函數(shù)當(dāng)作鎖――而且同步方法很可能還會被其他線程的對象訪問。

B．每個對象只有一個鎖（lock）與之相關(guān)聯(lián)科吭。

C．實(shí)現(xiàn)同步是要很大的系統(tǒng)開銷作為代價的昏滴，甚至可能造成死鎖，所以盡量避免無謂的同步控制对人。

接著來討論synchronized用到不同地方對代碼產(chǎn)生的影響：

假設(shè)P1谣殊、P2是同一個類的不同對象，這個類中定義了以下幾種情況的同步塊或同步方法牺弄，P1姻几、P2就都可以調(diào)用它們。

1． 把synchronized當(dāng)作函數(shù)修飾符時势告，示例代碼如下：

Public synchronized void methodAAA()
{
//….
}
這也就是同步方法鲜棠，那這時synchronized鎖定的是哪個對象呢？它鎖定的是調(diào)用這個同步方法對象培慌。也就是說，當(dāng)一個對象P1在不同的線程中執(zhí)行這個同步方法時柑爸，它們之間會形成互斥吵护，達(dá)到同步的效果。但是這個對象所屬的Class所產(chǎn)生的另一對象P2卻可以任意調(diào)用這個被加了synchronized關(guān)鍵字的方法表鳍。

上邊的示例代碼等同于如下代碼：

public void methodAAA()
{
synchronized (this) // (1)
{
//…..
}
}
(1)處的this指的是什么呢馅而？它指的就是調(diào)用這個方法的對象，如P1譬圣∥凸В可見同步方法實(shí)質(zhì)是將synchronized作用于object reference。――那個拿到了P1對象鎖的線程厘熟，才可以調(diào)用P1的同步方法屯蹦，而對P2而言，P1這個鎖與它毫不相干绳姨，程序也可能在這種情形下擺脫同步機(jī)制的控制登澜，造成數(shù)據(jù)混亂：（

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

        public void method3(SomeObject so)
          {
                 synchronized(so)

{
//…..
}
}
這時飘庄，鎖就是so這個對象脑蠕，誰拿到這個鎖誰就可以運(yùn)行它所控制的那段代碼。當(dāng)有一個明確的對象作為鎖時，就可以這樣寫程序谴仙，但當(dāng)沒有明確的對象作為鎖迂求，只是想讓一段代碼同步時怖侦，可以創(chuàng)建一個特殊的instance變量（它得是一個對象）來充當(dāng)鎖：

class Foo implements Runnable
{
private byte[] lock = new byte[0]; // 特殊的instance變量
Public void methodA()
{
synchronized(lock) { //… }
}
//…..
}
注：零長度的byte數(shù)組對象創(chuàng)建起來將比任何對象都經(jīng)濟(jì)――查看編譯后的字節(jié)碼：生成零長度的byte[]對象只需3條操作碼密似，而Object lock = new Object()則需要7行操作碼。

3．將synchronized作用于static 函數(shù)际插，示例代碼如下：

Class Foo
{
public synchronized static void methodAAA() // 同步的static 函數(shù)
{
//….
}
public void methodBBB()
{
synchronized(Foo.class) // class literal(類名稱字面常量)
}
}
代碼中的methodBBB()方法是把class literal作為鎖的情況哼审，它和同步的static函數(shù)產(chǎn)生的效果是一樣的谐腰，取得的鎖很特別，是當(dāng)前調(diào)用這個方法的對象所屬的類（Class涩盾，而不再是由這個Class產(chǎn)生的某個具體對象了）十气。

記得在《Effective Java》一書中看到過將 Foo.class和 P1.getClass()用于作同步鎖還不一樣，不能用P1.getClass()來達(dá)到鎖這個Class的目的春霍。P1指的是由Foo類產(chǎn)生的對象砸西。

可以推斷：如果一個類中定義了一個synchronized的static函數(shù)A，也定義了一個synchronized 的instance函數(shù)B址儒，那么這個類的同一對象Obj在多線程中分別訪問A和B兩個方法時芹枷，不會構(gòu)成同步，因?yàn)樗鼈兊逆i都不一樣莲趣。A方法的鎖是Obj這個對象鸳慈，而B的鎖是Obj所屬的那個Class。

總結(jié)一下：

1喧伞、線程同步的目的是為了保護(hù)多個線程反問一個資源時對資源的破壞走芋。
2、線程同步方法是通過鎖來實(shí)現(xiàn)潘鲫，每個對象都有切僅有一個鎖翁逞，這個鎖與一個特定的對象關(guān)聯(lián)，線程一旦獲取了對象鎖溉仑，其他訪問該對象的線程就無法再訪問該對象的其他非同步方法
3挖函、對于靜態(tài)同步方法，鎖是針對這個類的浊竟，鎖對象是該類的Class對象怨喘。靜態(tài)和非靜態(tài)方法的鎖互不干預(yù)。一個線程獲得鎖振定，當(dāng)在一個同步方法中訪問另外對象上的同步方法時哲思，會獲取這兩個對象鎖。
4吩案、對于同步棚赔，要時刻清醒在哪個對象上同步，這是關(guān)鍵。
5靠益、編寫線程安全的類丧肴，需要時刻注意對多個線程競爭訪問資源的邏輯和安全做出正確的判斷，對“原子”操作做出分析胧后，并保證原子操作期間別的線程無法訪問競爭資源芋浮。
6、當(dāng)多個線程等待一個對象鎖時壳快，沒有獲取到鎖的線程將發(fā)生阻塞纸巷。
7、死鎖是線程間相互等待鎖鎖造成的眶痰，在實(shí)際中發(fā)生的概率非常的小瘤旨。真讓你寫個死鎖程序，不一定好使竖伯，呵呵存哲。但是，一旦程序發(fā)生死鎖七婴，程序?qū)⑺赖簟?/p>

九祟偷、線程數(shù)據(jù)傳遞
在傳統(tǒng)的同步開發(fā)模式下，當(dāng)我們調(diào)用一個函數(shù)時打厘，通過這個函數(shù)的參數(shù)將數(shù)據(jù)傳入修肠，并通過這個函數(shù)的返回值來返回最終的計算結(jié)果。但在多線程的異步開發(fā)模式下户盯，數(shù)據(jù)的傳遞和返回和同步開發(fā)模式有很大的區(qū)別氛赐。由于線程的運(yùn)行和結(jié)束是不可預(yù)料的，因此先舷，在傳遞和返回數(shù)據(jù)時就無法象函數(shù)一樣通過函數(shù)參數(shù)和return語句來返回數(shù)據(jù)。

9.1滓侍、通過構(gòu)造方法傳遞數(shù)據(jù)
在創(chuàng)建線程時蒋川，必須要建立一個Thread類的或其子類的實(shí)例。因此撩笆，我們不難想到在調(diào)用start方法之前通過線程類的構(gòu)造方法將數(shù)據(jù)傳入線程捺球。并將傳入的數(shù)據(jù)使用類變量保存起來，以便線程使用(其實(shí)就是在run方法中使用)夕冲。下面的代碼演示了如何通過構(gòu)造方法來傳遞數(shù)據(jù)：

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();
}
}
由于這種方法是在創(chuàng)建線程對象的同時傳遞數(shù)據(jù)的氮兵，因此，在線程運(yùn)行之前這些數(shù)據(jù)就就已經(jīng)到位了歹鱼，這樣就不會造成數(shù)據(jù)在線程運(yùn)行后才傳入的現(xiàn)象泣栈。如果要傳遞更復(fù)雜的數(shù)據(jù)，可以使用集合、類等數(shù)據(jù)結(jié)構(gòu)南片。使用構(gòu)造方法來傳遞數(shù)據(jù)雖然比較安全掺涛，但如果要傳遞的數(shù)據(jù)比較多時，就會造成很多不便疼进。由于Java沒有默認(rèn)參數(shù)薪缆，要想實(shí)現(xiàn)類似默認(rèn)參數(shù)的效果，就得使用重載伞广，這樣不但使構(gòu)造方法本身過于復(fù)雜拣帽，又會使構(gòu)造方法在數(shù)量上大增。因此嚼锄，要想避免這種情況减拭，就得通過類方法或類變量來傳遞數(shù)據(jù)。
9.2灾票、通過變量和方法傳遞數(shù)據(jù)
向?qū)ο笾袀魅霐?shù)據(jù)一般有兩次機(jī)會峡谊，第一次機(jī)會是在建立對象時通過構(gòu)造方法將數(shù)據(jù)傳入，另外一次機(jī)會就是在類中定義一系列的public的方法或變量（也可稱之為字段）刊苍。然后在建立完對象后既们，通過對象實(shí)例逐個賦值。下面的代碼是對MyThread1類的改版正什，使用了一個setName方法來設(shè)置 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.3啥纸、通過回調(diào)函數(shù)傳遞數(shù)據(jù)
上面討論的兩種向線程中傳遞數(shù)據(jù)的方法是最常用的。但這兩種方法都是main方法中主動將數(shù)據(jù)傳入線程類的婴氮。這對于線程來說斯棒，是被動接收這些數(shù)據(jù)的。然而主经，在有些應(yīng)用中需要在線程運(yùn)行的過程中動態(tài)地獲取數(shù)據(jù)荣暮，如在下面代碼的run方法中產(chǎn)生了3個隨機(jī)數(shù)，然后通過Work類的process方法求這三個隨機(jī)數(shù)的和罩驻，并通過Data類的value將結(jié)果返回穗酥。從這個例子可以看出，在返回value之前惠遏，必須要得到三個隨機(jī)數(shù)砾跃。也就是說，這個 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); // 使用回調(diào)函數(shù)
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多線程的基礎(chǔ)知識就講到這里了，有興趣研究多線程的推薦直接看java的源碼透绩，你將會得到很大的提升翘骂！

林炳文Evankaka原創(chuàng)作品壁熄。轉(zhuǎn)載請注明出處http://blog.csdn.net/evankaka