寫在前面的話：
這篇博客是我從這里“轉(zhuǎn)載”的，為什么轉(zhuǎn)載兩個字加“”呢？因?yàn)檫@絕不是簡單的復(fù)制粘貼，我花了五六個小時對其中每一行的代碼都有認(rèn)真的練習(xí)，對其中的一些小錯誤進(jìn)行調(diào)整，并且重新排版，希望通過本篇博客可以讓自己對 Java 多線程有更好的理解，同時也希望能夠幫助正在學(xué)習(xí)多線程的你。
此文只能說是 Java 多線程的一個入門，其實(shí)Java里頭線程完全可以寫一本書了，但是如果最基本的你都沒掌握好，又怎么能更上一個臺階呢？如果你覺得此文很簡單，那推薦你看看Java并發(fā)包的的線程池（Java 并發(fā)編程與技術(shù)內(nèi)幕:線程池深入理解），或者看這個專欄：Java 并發(fā)編程與技術(shù)內(nèi)幕。你將會對 Java 里頭的高并發(fā)場景下的線程有更加深刻的理解
本文主要講了 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)多線程，有兩種手段：
- 一種是繼承 Thread 類；
- 一種是實(shí)現(xiàn) Runnable 接口.
其實(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 ，（筆者推薦使用 Runnable ，后頭會說明為什么）。下面來看一個簡單的實(shí)例：
/**
* Created by Sean on 2017/5/9.
*/
class Thread1 extends Thread {
private String threadName; // 用于標(biāo)示不同的線程
public Thread1(String threadName) {
this.threadName = threadName;
}
@Override
public void run() {
super.run();
for (int i = 0; i < 5; i++) {
System.out.println(threadName + "運(yùn)行，此時的 i = " + i);
try {
sleep((int) Math.random() * 10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class Main {
public static void main(String[] args) {
System.out.println("Hello World!");
Thread1 thread1 = new Thread1("我是A線程");
Thread1 thread2 = new Thread1("我是B線程");
thread1.start();
thread2.start();
}
}
運(yùn)行結(jié)果：
說明：
程序啟動運(yùn)行 main 時候， java 虛擬機(jī)啟動一個進(jìn)程，主線程 main 在
main() 調(diào)用時候被創(chuàng)建。隨著調(diào)用 Thread1 的兩個對象的 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異常。
比如把 Main 類代碼改成下面：
public class Main {
public static void main(String[] args) {
Thread1 thread1 = new Thread1("我是A線程");
thread1.start();
thread1.start();
}
}
結(jié)果如下：
二、實(shí)現(xiàn) java.lang.Runnable 接口
采用 Runnable 也是非常常見的一種，我們只需要重寫 run() 即可。下面也來看個實(shí)例。
使用繼承 Thread 實(shí)現(xiàn)共享的錯誤示范
/**
* Created by Sean on 2017/5/9.
*/
class Thread2 implements Runnable {
private String threadName;
public Thread2(String threadName) {
this.threadName = threadName;
}
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println(threadName + "運(yùn)行，此時的 i = " + i);
try {
Thread.sleep((int) Math.random() * 10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class Main2 {
public static void main(String[] args) {
new Thread(new Thread2("我是在A線程中")).start();
new Thread(new Thread2("我是在B線程中")).start();
}
}
結(jié)果：
說明：
Thread2 類是通過實(shí)現(xiàn) Runnable 接口，使該類有了多線程類的特征， run() 方法是多線程程序的一個約定，所有的多線程代碼都在 run() 方法里面， 事實(shí)上， Thread 類也是實(shí)現(xiàn)了 Runnable 接口的類。
在啟動實(shí)現(xiàn)了 Runnable 接口的類的多線程的時候，需要先通過 Thread 類的構(gòu)造方法 Thread(Runanable target) 構(gòu)造出 Thread 對象，然后調(diào)用 Thread 對象的 start() 方法來開啟線程，運(yùn)行 run() 方法里面的多線程代碼（這個run() 方法不需要開發(fā)者手動調(diào)用，會在操作系統(tǒng)分給該線程時間片的時候自動運(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)資源共享。
上面這句話是原博客里面給出的，我認(rèn)為是有瑕疵的。
以賣票程序?yàn)槔旅鎭碚f明為什么這樣說：
使用繼承 Thread 的方式共享的錯誤示例
/**
* Created by Sean on 2017/5/9.
*/
class Thread3 extends Thread {
private String threadName;
private int ticket = 5;
public Thread3(String threadName) {
this.threadName = threadName;
}
@Override
public void run() {
for (int i = 0; i < 5; i++) {
synchronized (this) {
if (ticket > 0){
System.out.println(threadName + "運(yùn)行，此時的 i = " + i+" 剩余票數(shù)" + this.ticket--);
}
}
try {
sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class Main3 {
public static void main(String[] args){
Thread3 thread1 = new Thread3("我是在A線程中");
Thread3 thread2 = new Thread3("我是在B線程中");
Thread3 thread3 = new Thread3("我是在C線程中");
thread1.start();
thread2.start();
thread3.start();
}
}
結(jié)果：
從上面的結(jié)果可以看到，開啟了三個線程，每個線程都賣了5張票，這明顯是不合理的，接下來看看用 Runnable 來實(shí)現(xiàn)共享 5 張票的例子
使用實(shí)現(xiàn) Runnable 實(shí)現(xiàn)共享票數(shù)
import static java.lang.Thread.currentThread;
import static java.lang.Thread.sleep;
/**
* Created by Sean on 2017/5/9.
*/
class Thread4 implements Runnable {
private int ticket = 5;
@Override
public void run() {
for (int i = 0; i < 5; i++) {
synchronized (this) {
if (ticket > 0) {
System.out.println(currentThread().getName() + "運(yùn)行，此時的 i = " + i + " 剩余票數(shù)" + this.ticket--);
}
}
try {
sleep(400);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class Main4 {
public static void main(String[] args) {
Thread4 thread1 = new Thread4();
new Thread(thread1, "我是在A線程中").start();
new Thread(thread1, "我是在B線程中").start();
new Thread(thread1, "我是在C線程中").start();
}
}
運(yùn)行結(jié)果：
可以看到，我們用實(shí)現(xiàn) Runnable 接口的方式實(shí)現(xiàn)了資源的共享。
那么我們使用繼承 Thread 的方式就真的沒法實(shí)現(xiàn)資源共享嗎？
答案是 NO！
往下看。
使用繼承 Thread 的方式共享的正確示例
我們先看下面的代碼：
/**
* Created by Sean on 2017/5/9.
*/
class Thread5 extends Thread {
private int ticket = 5;
@Override
public void run() {
for (int i = 0; i < 5; i++) {
synchronized (this) {
if (ticket > 0) {
System.out.println(currentThread().getName() + "運(yùn)行，此時的 i = " + i + " 剩余票數(shù)" + this.ticket--);
}
}
try {
sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class Main5 {
public static void main(String[] args) {
Thread5 thread1 = new Thread5();
new Thread(thread1, "我是在A線程中").start();
new Thread(thread1, "我是在B線程中").start();
new Thread(thread1, "我是在C線程中").start();
}
}
運(yùn)行結(jié)果：
可以看到，雖然我們使用了繼承 Thread 的方式來實(shí)現(xiàn)線程類，最后我們也同樣實(shí)現(xiàn)了多線程中資源的共享。
從而可以判斷，原博客的話是有一定錯誤的。
下面看一下總結(jié)：
實(shí)現(xiàn) Runnable 接口比繼承 Thread 類所具有的優(yōu)勢：
- 可以避免java中的單繼承的限制
- 線程池只能放入實(shí)現(xiàn) Runable 或 callable 類線程，不能直接放入繼承
Thread 的類
兩者都有的：
- 適合多個相同的程序代碼的線程去處理同一個資源
- 增加程序的健壯性，代碼可以被多個線程共享，代碼和數(shù)據(jù)獨(dú)立
提醒一下大家： main() 方法其實(shí)也是一個線程，在 java 中所有的線程都是同時啟動的，至于什么時候啟動，哪個線程先執(zhí)行，完全是看哪個線程先從 cpu 哪里獲取時間片資源。
此外：在 java 中，每次程序運(yùn)行至少啟動兩個線程， 一個是 main 線程， 一個是垃圾回收線程。因?yàn)槊慨?dāng)使用 java 命令執(zhí)行一個類的時候，實(shí)際上都會啟動一個 JVM ，每一個 JVM 實(shí)際就是在操作系統(tǒng)中啟動了一個進(jìn)程。
四、線程狀態(tài)轉(zhuǎn)換
下面的這個圖非常重要！你如果看懂了這個圖，那么對于多線程的理解將會更加深刻！
學(xué)過操作系統(tǒng)的同學(xué)應(yīng)該看起來很容易的，畢竟當(dāng)初考試的時候這一塊是個重點(diǎn)，沒少復(fù)習(xí)這一塊。
- 新建狀態(tài)（New）：新創(chuàng)建了一個線程對象
- 就緒狀態(tài)（Runnable）：線程對象創(chuàng)建后，其他線程調(diào)用了該對象的 start() 方法，該狀態(tài)的線程位于可運(yùn)行的線程池中，變?yōu)榭蛇\(yùn)行狀態(tài)，這個時候，只要獲取了 cpu 的執(zhí)行權(quán)，就可以運(yùn)行，進(jìn)入運(yùn)行狀態(tài)。
- 運(yùn)行狀態(tài)（Running）： 就緒狀態(tài)的線程從 cpu 獲得了執(zhí)行權(quán)之后，便可進(jìn)入此狀態(tài)，執(zhí)行 run() 方法里面的代碼。
-
阻塞狀態(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)行的線程在獲取對象的同步鎖時，如果該同步鎖被其他線程占用，這時此線程是無法運(yùn)行的，那么 JVM 就會把該線程放入鎖池中，導(dǎo)致阻塞
- 其他阻塞：運(yùn)行的線程執(zhí)行 sleep() 或者 join() 方法，或者發(fā)出了 I/O 請求，JVM 會把該線程置為阻塞狀態(tài)，當(dāng) sleep() 狀態(tài)超時、join() 等待線程終止或者超時、或者 I/O 處理完畢時，線程會重新進(jìn)入就緒狀態(tài)，（注意：sleep() 是不會釋放本身持有的鎖的）
- 死亡狀態(tài)（Dead）：線程執(zhí)行完了之后或者因?yàn)槌绦虍惓Ｍ顺隽?run() 方法，結(jié)束該線程的生命周期。
五、線程調(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)，回到另一個線程結(jié)束，當(dāng)前線程再由阻塞狀態(tài)變?yōu)榫途w狀態(tài)，等待 cpu 的寵幸。
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() 兩個方法已經(jīng)在 JDK 1.5 中廢除，此處不做介紹，因?yàn)橛兴梨i傾向。
六、常用函數(shù)說明
1. sleep(long millis): 在指定的毫秒數(shù)內(nèi)讓當(dāng)前正在執(zhí)行的線程休眠（暫停執(zhí)行）
2. join() 指等待t線程終止。
使用方式
Thread6 thread1 = new Thread6();
thread1.start();
thread1.join();
為什么要用join()方法
很多情況下，主線程生成并啟動了子線程，如果子線程需要大量的耗時運(yùn)算，主線程往往將于子線程結(jié)束之前結(jié)束，但是如果主線程處理完了其他事務(wù)后，需要用到子線程返回的結(jié)果，也就是需要主線程需要在子線程結(jié)束后再結(jié)束，這時候就要用到 join() 方法。
先看下不加 join() 的代碼：
/**
* Created by Sean on 2017/5/9.
*/
class Thread6 extends Thread {
@Override
public void run() {
super.run();
System.out.println(Thread.currentThread().getName() + "運(yùn)行開始!");
for (int i = 0; i < 5; i++) {
System.out.println(currentThread().getName() + "======>" + i);
try {
sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName() + "運(yùn)行結(jié)束!");
}
}
public class Main6 {
public static void main(String[] args) throws InterruptedException {
System.out.println(Thread.currentThread().getName() + "線程運(yùn)行開始!");
Thread6 thread1 = new Thread6();
Thread6 thread2 = new Thread6();
thread1.setName("線程A");
thread2.setName("線程B");
thread1.start();
thread2.start();
System.out.println("這時thread1 和 thread2 都執(zhí)行完畢之后才能執(zhí)行主線程打印此句話因?yàn)閮蓚€子線程都被主線程調(diào)用了join() 方法");
System.out.println(Thread.currentThread().getName() + "線程運(yùn)行結(jié)束!");
}
}
結(jié)果：
從結(jié)果中可以看到我們打印的 main 線程運(yùn)行結(jié)束之后，兩個子線程才開始執(zhí)行，這和上面說的是對照的，
下面演示下等待兩個子線程結(jié)束之后再結(jié)束主線程：
/**
* Created by Sean on 2017/5/9.
*/
class Thread6 extends Thread {
@Override
public void run() {
super.run();
System.out.println(Thread.currentThread().getName() + "運(yùn)行開始!");
for (int i = 0; i < 5; i++) {
System.out.println(currentThread().getName() + "======>" + i);
try {
sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName() + "運(yùn)行結(jié)束!");
}
}
public class Main6 {
public static void main(String[] args) throws InterruptedException {
System.out.println(Thread.currentThread().getName() + "線程運(yùn)行開始!");
Thread6 thread1 = new Thread6();
Thread6 thread2 = new Thread6();
thread1.setName("線程A");
thread2.setName("線程B");
thread1.start();
try {
thread1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
thread2.start();
try {
thread2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("這時thread1 和 thread2 都執(zhí)行完畢之后才能執(zhí)行主線程打印此句話因?yàn)閮蓚€子線程都被主線程調(diào)用了join() 方法");
System.out.println(Thread.currentThread().getName() + "線程運(yùn)行結(jié)束!");
}
}
運(yùn)行結(jié)果：
這個時候不論執(zhí)行多少遍，都是主線程等待子線程結(jié)束后才結(jié)束。
如果主線程的執(zhí)行需要依賴于子線程中的完整數(shù)據(jù)的時候，這種方法就可以很好的確保兩個線程的同步性。
3. yield():暫停當(dāng)前正在執(zhí)行的線程對象，并執(zhí)行其他線程。
注意：yield() 應(yīng)該做的是讓當(dāng)前運(yùn)行線程回到可運(yùn)行狀態(tài)（就緒狀態(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)（就緒狀態(tài)），但有可能沒有效果?？煽瓷厦娴膱D。
看下面的例子：
/**
* yield()的用法
* Created by Sean on 2017/5/9.
*/
class Thread7 extends Thread {
@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 Main7 {
public static void main(String[] args) {
Thread7 thread1 = new Thread7();
Thread7 thread2 = new Thread7();
thread1.setName("A線程");
thread2.setName("B線程");
thread1.start();
thread2.start();
}
}
運(yùn)行結(jié)果：
第一種情況：A線程當(dāng)執(zhí)行到30時會CPU時間讓掉，這時A線程搶到 CPU 的時間片執(zhí)行。
第二種情況：B線程當(dāng)執(zhí)行到30時會CPU時間讓掉，這時A線程搶到 CPU 的時間片執(zhí)行。
第二種情況：從一開始就交替執(zhí)行，當(dāng)?shù)?0的時候進(jìn)行一次讓步。
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)行。
4. 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);
5. interrupt()
不要以為它是中斷某個線程！它只是線線程發(fā)送一個中斷信號，讓線程在無限等待時（如死鎖時）能拋出拋出，從而結(jié)束線程，但是如果你吃掉了這個異常，那么這個線程還是不會中斷的！
6. wait() 暫停線程，釋放 cpu 控制權(quán)，同時釋放對象鎖的控制
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() 練習(xí)
* Created by Sean on 2017/5/9.
*/
class Thread8 implements Runnable {
private String name;
private Object prev;
private Object self;
private Thread8(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) { // 當(dāng)前對象鎖
System.out.print(name + ((count == 1 && name.equals("C")) ? "" : "->"));
count--;
self.notify(); // 喚醒下一個等待線程
}
try {
prev.wait();// 釋放當(dāng)前線程
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public static void main(String[] args) throws InterruptedException {
Object a = new Object();
Object b = new Object();
Object c = new Object();
Thread8 threadA = new Thread8("A", c, a);//c是上個對象,a是當(dāng)前對象
Thread8 threadB = new Thread8("B", a, b);//a是上個對象,b是當(dāng)前對象
Thread8 threadC = new Thread8("C", b, c);//b是上個對象,c是當(dāng)前對象
new Thread(threadA).start();
Thread.sleep(100); //確保按順序A、B、C執(zhí)行
new Thread(threadB).start();
Thread.sleep(100); //確保按順序A、B、C執(zhí)行
new Thread(threadC).start();
Thread.sleep(100); //確保按順序A、B、C執(zhí)行
}
}
輸出結(jié)果：
先來解釋一下其整體思路，從大的方向上來講，該問題為三線程間的同步喚醒操作，主要的目的就是 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é)束后再次被喚醒。
通過上面代碼可以看到， A、B、C 都被順序打印了十次，過程是這樣的：
- 打印A：A 線程先運(yùn)行，A 線程持有 C、A對像鎖，因?yàn)镃對象鎖對應(yīng)上一個打印的線程，A 對象鎖對應(yīng)自己打印的線程。然后在自身對象鎖中
synchronized (self) { }執(zhí)行完之后喚醒下一個打印線程，然后在上一個對象鎖synchronized (prev) { }中暫停線程、釋放 CPU 的控制權(quán)，同時釋放 C 對象鎖的控制權(quán) - 打印B：拿到線程 A 釋放的 A 對像鎖，然后獲取自身的 B 對象鎖，重復(fù)上面“打印A”的步驟
- 打印C：拿到線程 B 釋放的 B 對像鎖，然后獲取自身的 C 對象鎖，重復(fù)上面“打印A”的步驟
- 打印A：拿到線程 C 釋放的 C 對像鎖，然后獲取自身的 A 對象鎖，重復(fù)上面“打印A”的步驟
.
.
.
.
.
這樣一直執(zhí)行到程序結(jié)束全部打印完畢。
wait() 和 sleep() 區(qū)別
- 共同點(diǎn)：
- 他們都是在多線程的環(huán)境下，都可以在程序的調(diào)用處阻塞指定的毫秒數(shù)，并返回。
- 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)：
- Thread類的方法：sleep(),yield()等
Object的方法：wait()和notify()等 - 每個對象都有一個鎖來控制同步訪問。Synchronized關(guān)鍵字可以和對象的鎖交互，來實(shí)現(xiàn)線程的同步。
sleep方法沒有釋放鎖，而wait方法釋放了鎖，使得其他線程可以使用同步控制塊或者方法。 - 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“異常。
七、常見線程名詞解釋以及常用方法
1. 名詞解釋
- 主線程：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è)置一個線程是否為后臺線程。
2. 線程類的一些常用方法：
- 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)先級。
- getPriority():：獲得一個線程的優(yōu)先級。
八、線程同步
1、synchronized關(guān)鍵字的作用域
- 是某個對象實(shí)例內(nèi)，
synchronized aMethod(){}可以防止多個線程同時訪問這個對象的 synchronized 方法（如果一個對象有多個 synchronized 方法，只要一個線程訪問了其中的一個 synchronized 方法，其它線程不能同時訪問這個對象中任何一個 synchronized 方法）。這時，不同的對象實(shí)例的 synchronized 方法是不相干擾的。也就是說，其它線程照樣可以同時訪問相同類的另一個對象實(shí)例中的 synchronized 方法； - 是某個類的范圍，
synchronized static aStaticMethod{}防止多個線程同時訪問這個類中的 synchronized static 方法。它可以對類的所有對象實(shí)例起作用。
2、synchronized關(guān)鍵字實(shí)現(xiàn)互斥訪問
除了方法前用 synchronized 關(guān)鍵字， synchronized 關(guān)鍵字還可以用于方法中的某個區(qū)塊中，表示只對這個區(qū)塊的資源實(shí)行互斥訪問。用法是: synchronized(this){/*區(qū)塊*/}，它的作用域是當(dāng)前對象；
3. 不能繼承
synchronized 關(guān)鍵字是不能繼承的，也就是說，基類的方法 synchronized f(){}在繼承類中并不自動是synchronized f(){}，而是變成了 f(){} 。繼承類需要你顯式的指定它的某個方法為 synchronized 方法；
4. 用法
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)：
- 無論synchronized關(guān)鍵字加在方法上還是對象上，它取得的鎖都是對象，而不是把一段代碼或函數(shù)當(dāng)作鎖――而且同步方法很可能還會被其他線程的對象訪問。
- 每個對象只有一個鎖（lock）與之相關(guān)聯(lián)。
- 實(shí)現(xiàn)同步是要很大的系統(tǒng)開銷作為代價的，甚至可能造成死鎖，所以盡量避免無謂的同步控制。
接著來討論synchronized用到不同地方對代碼產(chǎn)生的影響：
假設(shè)P1、P2是同一個類的不同對象，這個類中定義了以下幾種情況的同步塊或同步方法，P1、P2就都可以調(diào)用它們。
把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é)
- 線程同步的目的是為了保護(hù)多個線程反問一個資源時對資源的破壞。
- 線程同步方法是通過鎖來實(shí)現(xiàn)，每個對象都有切僅有一個鎖，這個鎖與一個特定的對象關(guān)聯(lián)，線程一旦獲取了對象鎖，其他訪問該對象的線程就無法再訪問該對象的其他非同步方法
- 對于靜態(tài)同步方法，鎖是針對這個類的，鎖對象是該類的Class對象。靜態(tài)和非靜態(tài)方法的鎖互不干預(yù)。一個線程獲得鎖，當(dāng)在一個同步方法中訪問另外對象上的同步方法時，會獲取這兩個對象鎖。
- 對于同步，要時刻清醒在哪個對象上同步，這是關(guān)鍵。
- 編寫線程安全的類，需要時刻注意對多個線程競爭訪問資源的邏輯和安全做出正確的判斷，對“原子”操作做出分析，并保證原子操作期間別的線程無法訪問競爭資源。
- 當(dāng)多個線程等待一個對象鎖時，沒有獲取到鎖的線程將發(fā)生阻塞。
- 死鎖是線程間相互等待鎖鎖造成的，在實(shí)際中發(fā)生的概率非常的小。真讓你寫個死鎖程序，不一定好使，呵呵。但是，一旦程序發(fā)生死鎖，程序?qū)⑺赖簟?/li>
九、線程數(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ù)。
1. 通過構(gòu)造方法傳遞數(shù)據(jù)
在創(chuàng)建線程時，必須要建立一個 Thread 類的或其子類的實(shí)例。因此，我們不難想到在調(diào)用 start 方法之前通過線程類的構(gòu)造方法將數(shù)據(jù)傳入線程。并將傳入的數(shù)據(jù)使用類變量保存起來，以便線程使用(其實(shí)就是在 run 方法中使用)。下面的代碼演示了如何通過構(gòu)造方法來傳遞數(shù)據(jù)：
/**
* Created by Sean on 2017/5/9.
*/
class Thread9 extends Thread {
private String threadName;
public Thread9(String threadName) {
this.threadName = threadName;
}
public void run() {
System.out.println("hello " + threadName);
}
}
public class Main9 {
public static void main(String[] args) {
Thread9 thread = new Thread9("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ù)。
2. 通過變量和方法傳遞數(shù)據(jù)
向?qū)ο笾袀魅霐?shù)據(jù)一般有兩次機(jī)會：
- 第一次機(jī)會是在建立對象時通過構(gòu)造方法將數(shù)據(jù)傳入；
- 另外一次機(jī)會就是在類中定義一系列的 public 的方法或變量（也可稱之為字段）。然后在建立完對象后，通過對象實(shí)例逐個賦值。下面的代碼是對Thread9 類的改版，使用了一個 setThreadName 方法來設(shè)置 threadName 變量：
/**
* Created by Sean on 2017/5/9.
*/
class Thread9 extends Thread {
private String threadName;
public Thread9(String threadName) {
this.threadName = threadName;
}
public String getThreadName() {
return threadName;
}
public void setThreadName(String threadName) {
this.threadName = threadName;
}
public void run() {
System.out.println("hello " + threadName);
}
}
public class Main9 {
public static void main(String[] args) {
Thread9 thread = new Thread9("world");
thread.start();
}
}
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 是無法事先就傳入線程類的。
/**
* 回調(diào)實(shí)現(xiàn)多線程傳遞數(shù)據(jù)
* Created by Sean on 2017/5/9.
*/
class Data {
public int value = 0;
}
class Work {
public void process(Data data, Integer[] numbers) {
for (int n : numbers) {
data.value += n;
}
}
}
class Thread10 extends Thread {
private Work work;
public Thread10(Work work) {
this.work = work;
}
@Override
public void run() {
super.run();
Integer[] numbers = new Integer[3];
java.util.Random random = new java.util.Random();
Data data = new Data();
for (int i = 0; i < numbers.length; i++) {
numbers[i] = random.nextInt(100);
}
work.process(data,numbers);
System.out.println(String.valueOf(numbers[0]) + "+" + String.valueOf(numbers[1]) + "+"
+ String.valueOf(numbers[2]) + "=" + data.value);
}
public static void main(String[] args)
{
Thread thread = new Thread10(new Work());
thread.start();
}
}
多線程就寫到這里了，基本都是按照這篇博客敲的，每個貼的代碼都是親自重寫、驗(yàn)證，都是可執(zhí)行的，雖然花了很多時間，但是自己對多線程有了更深層次的認(rèn)識，希望這篇文章可以幫到大家。
林炳文Evankaka原創(chuàng)作品。出處http://blog.csdn.net/evankaka
