【學習】002多線程之間實現同步

課程目標

一、理解線程安全？

二、synchronized用法

三、死鎖

四、Java內存模型

五、Vlolatile

六、ThreadLock

什麼是線程安全？

爲何有線程安全問題？

當多個線程同時共享，同一個全局變量或靜態變量，作寫的操做時，可能會發生數據衝突問題，也就是線程安全問題。可是作讀操做是不會發生數據衝突問題。

案例:需求如今有100張火車票，有兩個窗口同時搶火車票，請使用多線程模擬搶票效果。

代碼:

package hongmoshui.com.cnblogs.www.study.day002; /** * 一號窗口和二號窗口同時出售火車第一張和第七張,部分火車票會重複出售。 結論發現，多個線程共享同一個全局成員變量時，作寫的操做可能會發生數據衝突問題。 * @author 洪墨水 */
class ThreadTrain1 implements Runnable { private int count = 100; private static Object oj = new Object(); @Override public void run() { while (count > 0) { try { Thread.sleep(50); } catch (Exception e) { // TODO: handle exception
 } sale(); } } public void sale() { // 前提 多線程進行使用、多個線程只能拿到一把鎖。 // 保證只能讓一個線程 在執行 缺點效率下降 // synchronized (oj) { // if (count > 0) {
        System.out.println(Thread.currentThread().getName() + ",出售第" + (100 - count + 1) + "票"); count--; // } // }
 } } public class ThreadDemo { public static void main(String[] args) { ThreadTrain1 threadTrain1 = new ThreadTrain1(); Thread t1 = new Thread(threadTrain1, "①號窗口"); Thread t2 = new Thread(threadTrain1, "②號窗口"); t1.start(); t2.start(); } }

 運行結果:

一號窗口和二號窗口同時出售火車第一張和第七張,部分火車票會重複出售。

結論發現，多個線程共享同一個全局成員變量時，作寫的操做可能會發生數據衝突問題。

 線程安全解決辦法:

問:如何解決多線程之間線程安全問題?

答:使用多線程之間同步synchronized或使用鎖(lock)。

問:爲何使用線程同步或使用鎖能解決線程安全問題呢？

答:將可能會發生數據衝突問題(線程不安全問題)，只能讓當前一個線程進行執行。代碼執行完成後釋放鎖，讓後才能讓其餘線程進行執行。這樣的話就能夠解決線程不安全問題。

問:什麼是多線程之間同步？

答:當多個線程共享同一個資源,不會受到其餘線程的干擾。

同步代碼塊

什麼是同步代碼塊？

答:就是將可能會發生線程安全問題的代碼，給包括起來。

synchronized(同一個數據){

 可能會發生線程衝突問題

}

就是同步代碼塊 

synchronized(對象)//這個對象能夠爲任意對象 

{ 

    須要被同步的代碼 

} 

 

對象如同鎖，持有鎖的線程能夠在同步中執行 

沒持有鎖的線程即便獲取CPU的執行權，也進不去 

同步的前提： 

1，必需要有兩個或者兩個以上的線程 

2，必須是多個線程使用同一個鎖 

必須保證同步中只能有一個線程在運行 

好處：解決了多線程的安全問題 

弊端：多個線程須要判斷鎖，較爲消耗資源、搶鎖的資源。 

 

代碼樣例:

private static Object oj = new Object(); public void sale() { // 前提 多線程進行使用、多個線程只能拿到一把鎖。 // 保證只能讓一個線程 在執行 缺點效率下降
        synchronized (oj) { if (count > 0) { System.out.println(Thread.currentThread().getName() + ",出售第" + (100 - count + 1) + "票"); count--; } } }

同步函數

   什麼是同步函數？

   答：在方法上修飾synchronized 稱爲同步函數

 代碼樣例

public synchronized void sale() { if (trainCount > 0) { try { Thread.sleep(40); } catch (Exception e) { } System.out.println(Thread.currentThread().getName() + ",出售 第" + (100 - trainCount + 1) + "張票."); trainCount--; } }

同窗們思考問題？同步函數用的是什麼鎖？

答：同步函數使用this鎖。

證實方式: 一個線程使用同步代碼塊(this明鎖),另外一個線程使用同步函數。若是兩個線程搶票不能實現同步，那麼會出現數據錯誤。

代碼:

package hongmoshui.com.cnblogs.www.study.day002; class ThreadTrain2 implements Runnable { private int count = 100; public boolean flag = true; private static Object oj = new Object(); @Override public void run() { if (flag) { while (count > 0) { synchronized (this) { if (count > 0) { try { Thread.sleep(50); } catch (Exception e) { // TODO: handle exception
 } System.out.println(Thread.currentThread().getName() + ",出售第" + (100 - count + 1) + "票"); count--; } } } } else { while (count > 0) { sale(); } } } public synchronized void sale() { // 前提 多線程進行使用、多個線程只能拿到一把鎖。 // 保證只能讓一個線程 在執行 缺點效率下降 // synchronized (oj) {
        if (count > 0) { try { Thread.sleep(50); } catch (Exception e) { // TODO: handle exception
 } System.out.println(Thread.currentThread().getName() + ",出售第" + (100 - count + 1) + "票"); count--; } // }
 } } public class ThreadDemo2 { public static void main(String[] args) throws InterruptedException { ThreadTrain2 threadTrain1 = new ThreadTrain2(); Thread t1 = new Thread(threadTrain1, "①號窗口"); Thread t2 = new Thread(threadTrain1, "②號窗口"); t1.start(); Thread.sleep(40); threadTrain1.flag = false; t2.start(); } }

靜態同步函數

答：什麼是靜態同步函數？

方法上加上static關鍵字，使用synchronized 關鍵字修飾 或者使用類.class文件。

靜態的同步函數使用的鎖是  該函數所屬字節碼文件對象

能夠用 getClass方法獲取，也能夠用當前  類名.class 表示。

代碼樣例:

synchronized(ThreadTrain.class) { System.out.println(Thread.currentThread().getName() + ",出售 第" + (100 - trainCount + 1) + "張票."); trainCount--; try { Thread.sleep(100); } catch (Exception e) { } }

總結：

synchronized 修飾方法使用鎖是當前this鎖。

synchronized 修飾靜態方法使用鎖是當前類的字節碼文件

多線程死鎖

 什麼是多線程死鎖？

   答:同步中嵌套同步,致使鎖沒法釋放

 代碼:

package hongmoshui.com.cnblogs.www.study.day002; /** * 多線程死鎖【同步中嵌套同步,致使鎖沒法釋放】 * @author 洪墨水 */
class ThreadTrain6 implements Runnable { // 這是貨票總票數,多個線程會同時共享資源
    private int trainCount = 100; public boolean flag = true; private Object mutex = new Object(); @Override public void run() { if (flag) { while (true) { synchronized (mutex) { // 鎖(同步代碼塊)在何時釋放？ 代碼執行完， 自動釋放鎖. // 若是flag爲true 先拿到 obj鎖,在拿到this 鎖、 才能執行。 // 若是flag爲false先拿到this,在拿到obj鎖，才能執行。 // 死鎖解決辦法:不要在同步中嵌套同步。
 sale(); } } } else { while (true) { sale(); } } } /** * 出售火車票 * @author: 洪墨水 */
    public synchronized void sale() { synchronized (mutex) { if (trainCount > 0) { try { Thread.sleep(40); } catch (Exception e) { } System.out.println(Thread.currentThread().getName() + ",出售 第" + (100 - trainCount + 1) + "張票."); trainCount--; } } } } public class DeadlockThread { public static void main(String[] args) throws InterruptedException { ThreadTrain6 threadTrain = new ThreadTrain6(); // 定義 一個實例
        Thread thread1 = new Thread(threadTrain, "一號窗口"); Thread thread2 = new Thread(threadTrain, "二號窗口"); thread1.start(); Thread.sleep(40); threadTrain.flag = false; thread2.start(); } }

多線程有三大特性

原子性、可見性、有序性

什麼是原子性

即一個操做或者多個操做 要麼所有執行而且執行的過程不會被任何因素打斷，要麼就都不執行。

一個很經典的例子就是銀行帳戶轉帳問題：
好比從帳戶A向帳戶B轉1000元，那麼必然包括2個操做：從帳戶A減去1000元，往帳戶B加上1000元。這2個操做必需要具有原子性才能保證不出現一些意外的問題。

咱們操做數據也是如此，好比i = i+1；其中就包括，讀取i的值，計算i，寫入i。這行代碼在Java中是不具有原子性的，則多線程運行確定會出問題，因此也須要咱們使用同步和lock這些東西來確保這個特性了。

原子性其實就是保證數據一致、線程安全一部分，

什麼是可見性

當多個線程訪問同一個變量時，一個線程修改了這個變量的值，其餘線程可以當即看獲得修改的值。

若兩個線程在不一樣的cpu，那麼線程1改變了i的值還沒刷新到主存，線程2又使用了i，那麼這個i值確定仍是以前的，線程1對變量的修改線程沒看到這就是可見性問題。

什麼是有序性

程序執行的順序按照代碼的前後順序執行。

通常來講處理器爲了提升程序運行效率，可能會對輸入代碼進行優化，它不保證程序中各個語句的執行前後順序同代碼中的順序一致，可是它會保證程序最終執行結果和代碼順序執行的結果是一致的。以下：

int a = 10;    //語句1

int r = 2;    //語句2
 a = a + 3;    //語句3
 r = a*a;     //語句4

則由於重排序，他還可能執行順序爲 2-1-3-4，1-3-2-4
但毫不可能 2-1-4-3，由於這打破了依賴關係。
顯然重排序對單線程運行是不會有任何問題，而多線程就不必定了，因此咱們在多線程編程時就得考慮這個問題了。

Java內存模型

共享內存模型指的就是Java內存模型(簡稱JMM)，JMM決定一個線程對共享變量的寫入時,能對另外一個線程可見。從抽象的角度來看，JMM定義了線程和主內存之間的抽象關係：線程之間的共享變量存儲在主內存（main memory）中，每一個線程都有一個私有的本地內存（local memory），本地內存中存儲了該線程以讀/寫共享變量的副本。本地內存是JMM的一個抽象概念，並不真實存在。它涵蓋了緩存，寫緩衝區，寄存器以及其餘的硬件和編譯器優化。

從上圖來看，線程A與線程B之間如要通訊的話，必需要經歷下面2個步驟：

1. 首先，線程A把本地內存A中更新過的共享變量刷新到主內存中去。

2. 而後，線程B到主內存中去讀取線程A以前已更新過的共享變量。

下面經過示意圖來講明這兩個步驟：

如上圖所示，本地內存A和B有主內存中共享變量x的副本。假設初始時，這三個內存中的x值都爲0。線程A在執行時，把更新後的x值（假設值爲1）臨時存放在本身的本地內存A中。當線程A和線程B須要通訊時，線程A首先會把本身本地內存中修改後的x值刷新到主內存中，此時主內存中的x值變爲了1。隨後，線程B到主內存中去讀取線程A更新後的x值，此時線程B的本地內存的x值也變爲了1。

從總體來看，這兩個步驟實質上是線程A在向線程B發送消息，並且這個通訊過程必需要通過主內存。JMM經過控制主內存與每一個線程的本地內存之間的交互，來爲java程序員提供內存可見性保證。

總結：什麼是Java內存模型：java內存模型簡稱jmm，定義了一個線程對另外一個線程可見。共享變量存放在主內存中，每一個線程都有本身的本地內存，當多個線程同時訪問一個數據的時候，可能本地內存沒有及時刷新到主內存，因此就會發生線程安全問題。

 Volatile

什麼是Volatile

Volatile 關鍵字的做用是變量在多個線程之間可見。

代碼:

package hongmoshui.com.cnblogs.www.study.day002; class ThreadVolatileDemo extends Thread { public boolean flag = true; @Override public void run() { System.out.println("開始執行子線程...."); while (flag) { } System.out.println("線程中止"); } public void setRuning(boolean flag) { this.flag = flag; } } public class ThreadVolatile { public static void main(String[] args) throws InterruptedException { ThreadVolatileDemo threadVolatileDemo = new ThreadVolatileDemo(); threadVolatileDemo.start(); Thread.sleep(3000); threadVolatileDemo.setRuning(false); System.out.println("flag 已經設置成false"); Thread.sleep(1000); System.out.println(threadVolatileDemo.flag); } }

運行結果:

 

已經將結果設置爲fasle爲何？還一直在運行呢。

緣由:線程之間是不可見的，讀取的是副本，沒有及時讀取到主內存結果。

解決辦法：使用Volatile關鍵字將解決線程之間可見性, 強制線程每次讀取該值的時候都去「主內存」中取值

Volatile非原子性

注意: Volatile非原子性

package hongmoshui.com.cnblogs.www.study.day002; /** * Volatile非原子性 * @author 洪墨水 */
public class VolatileNoAtomic extends Thread { private static volatile int count; // private static AtomicInteger count = new AtomicInteger(0);
    private static void addCount() { for (int i = 0; i < 1000; i++) { count++; // count.incrementAndGet();
 } System.out.println(count); } public void run() { addCount(); } public static void main(String[] args) { VolatileNoAtomic[] arr = new VolatileNoAtomic[100]; for (int i = 0; i < 10; i++) { arr[i] = new VolatileNoAtomic(); } for (int i = 0; i < 10; i++) { arr[i].start(); } } }

運行結果:

 

結果發現： 數據不一樣步，由於Volatile不用具有原子性。

使用AtomicInteger原子類

AtomicInteger是一個提供原子操做的Integer類，經過線程安全的方式操做加減。

 

package com.hongmoshui.test02; import java.util.concurrent.atomic.AtomicInteger; /** * AtomicInteger是一個提供原子操做的Integer類，經過線程安全的方式操做加減 * @author 洪墨水 */
public class AtomicIntegerAtomic extends Thread { private static AtomicInteger atomicInteger = new AtomicInteger(0); @Override public void run() { for (int i = 0; i < 1000; i++) { // 等同於i++
 atomicInteger.incrementAndGet(); } System.out.println(atomicInteger); } public static void main(String[] args) { // 初始化10個線程
        AtomicIntegerAtomic[] volatileNoAtomic = new AtomicIntegerAtomic[10]; for (int i = 0; i < 10; i++) { // 建立
            volatileNoAtomic[i] = new AtomicIntegerAtomic(); } for (int i = 0; i < volatileNoAtomic.length; i++) { volatileNoAtomic[i].start(); } } }

 

volatile與synchronized區別

僅靠volatile不能保證線程的安全性。（原子性）

①volatile輕量級，只能修飾變量。synchronized重量級，還可修飾方法

②volatile只能保證數據的可見性，不能用來同步，由於多個線程併發訪問volatile修飾的變量不會阻塞。

synchronized不只保證可見性，並且還保證原子性，由於，只有得到了鎖的線程才能進入臨界區，從而保證臨界區中的全部語句都所有執行。多個線程爭搶synchronized鎖對象時，會出現阻塞。

線程安全性

線程安全性包括兩個方面，①可見性。②原子性。

從上面自增的例子中能夠看出：僅僅使用volatile並不能保證線程安全性。而synchronized則可實現線程的安全性。

ThreadLocal

什麼是ThreadLocal

 ThreadLocal提供一個線程的局部變量，訪問某個線程擁有本身局部變量。

 當使用ThreadLocal維護變量時，ThreadLocal爲每一個使用該變量的線程提供獨立的變量副本，因此每個線程均可以獨立地改變本身的副本，而不會影響其它線程所對應的副本。

ThreadLocal的接口方法

ThreadLocal類接口很簡單，只有4個方法，咱們先來了解一下：

• void set(Object value)設置當前線程的線程局部變量的值。

• public Object get()該方法返回當前線程所對應的線程局部變量。

• public void remove()將當前線程局部變量的值刪除，目的是爲了減小內存的佔用，該方法是JDK 5.0新增的方法。須要指出的是，當線程結束後，對應該線程的局部變量將自動被垃圾回收，因此顯式調用該方法清除線程的局部變量並非必須的操做，但它能夠加快內存回收的速度。

• protected Object initialValue()返回該線程局部變量的初始值，該方法是一個protected的方法，顯然是爲了讓子類覆蓋而設計的。這個方法是一個延遲調用方法，在線程第1次調用get()或set(Object)時才執行，而且僅執行1次。ThreadLocal中的缺省實現直接返回一個null。

案例:建立三個線程，每一個線程生成本身獨立序列號。

代碼:

package hongmoshui.com.cnblogs.www.study.day002; /** * 建立三個線程，每一個線程生成本身獨立序列號 * @author 洪墨水 */
class Res { // 生成序列號共享變量
    public static Integer count = 0; public static ThreadLocal<Integer> threadLocal = new ThreadLocal<Integer>() { protected Integer initialValue() { return 0; }; }; public Integer getNum() { int count = threadLocal.get() + 1; threadLocal.set(count); return count; } } public class ThreadLocaDemo2 extends Thread { private Res res; public ThreadLocaDemo2(Res res) { this.res = res; } @Override public void run() { for (int i = 0; i < 3; i++) { System.out.println(Thread.currentThread().getName() + "---" + "i---" + i + "--num:" + res.getNum()); } } public static void main(String[] args) { Res res = new Res(); ThreadLocaDemo2 threadLocaDemo1 = new ThreadLocaDemo2(res); ThreadLocaDemo2 threadLocaDemo2 = new ThreadLocaDemo2(res); ThreadLocaDemo2 threadLocaDemo3 = new ThreadLocaDemo2(res); threadLocaDemo1.start(); threadLocaDemo2.start(); threadLocaDemo3.start(); } }

ThreadLocal實現原理

ThreadLocal經過map集合

Map.put(「當前線程」,值)；

練習題

設計4個線程，其中兩個線程每次對j增長1，另外兩個線程對j每次減小1。寫出程序。

 

多線程之間如何實現通信

什麼是多線程之間通信？

   多線程之間通信，其實就是多個線程在操做同一個資源，可是操做的動做不一樣。

   畫圖演示

多線程之間通信需求

  需求:第一個線程寫入(input)用戶，另外一個線程取讀取(out)用戶.實現讀一個，寫一個操做。

代碼實現基本實現

共享資源源實體類

package com.hongmoshui.test03; class Res { public String userSex; public String userName; }

輸入線程資源

package com.hongmoshui.test03; class IntThrad extends Thread { private Res res; public IntThrad(Res res) { this.res = res; } @Override public void run() { int count = 0; while (true) { if (count == 0) { res.userName = "洪墨水"; res.userSex = "男"; } else { res.userName = "小紅"; res.userSex = "女"; } count = (count + 1) % 2; } } }

輸出線程

package com.hongmoshui.test03; class OutThread extends Thread { private Res res; public OutThread(Res res) { this.res = res; } @Override public void run() { while (true) { System.out.println(res.userName + "--" + res.userSex); } } }

運行代碼

package com.hongmoshui.test03; public class Test { public static void main(String[] args) { Res res = new Res(); IntThrad intThrad = new IntThrad(res); OutThread outThread = new OutThread(res); intThrad.start(); outThread.start(); } }

結果：

洪墨水--女
小紅--男
洪墨水--女
洪墨水--女
洪墨水--女
小紅--男

。。。。

注意：數據發生錯亂，形成線程安全問題

解決線程安全問題

IntThrad 加上synchronized

package com.hongmoshui.test03; class IntThrad extends Thread { private Res res; public IntThrad(Res res) { this.res = res; } @Override public void run() { int count = 0; while (true) { synchronized (res) { if (count == 0) { res.userName = "洪墨水"; res.userSex = "男"; } else { res.userName = "小紅"; res.userSex = "女"; } count = (count + 1) % 2; } } } }

輸出線程加上synchronized

package com.hongmoshui.test03; class OutThread extends Thread { private Res res; public OutThread(Res res) { this.res = res; } @Override public void run() { while (true) { synchronized (res) { System.out.println(res.userName + "--" + res.userSex); } } } }

wait()、notify、notifyAll()方法

wait()、notify()、notifyAll()是三個定義在Object類裏的方法，能夠用來控制線程的狀態。

這三個方法最終調用的都是jvm級的native方法。隨着jvm運行平臺的不一樣可能有些許差別。

 若是對象調用了wait方法就會使持有該對象的線程把該對象的控制權交出去，而後處於等待狀態。

若是對象調用了notify方法就會通知某個正在等待這個對象的控制權的線程能夠繼續運行。

若是對象調用了notifyAll方法就會通知全部等待這個對象控制權的線程繼續運行。

注意:必定要在線程同步中使用,而且是同一個鎖的資源

 

package com.hongmoshui.test03; class Res { public String userSex; public String userName; // 線程通信標識
    public boolean flag = false; }

package com.hongmoshui.test03; class IntThrad extends Thread { private Res res; public IntThrad(Res res) { this.res = res; } @Override public void run() { int count = 0; while (true) { synchronized (res) { if (res.flag) { try { // 當前線程變爲等待，可是能夠釋放鎖
 res.wait(); } catch (Exception e) { e.printStackTrace(); } } if (count == 0) { res.userName = "洪墨水"; res.userSex = "男"; } else { res.userName = "小紅"; res.userSex = "女"; } count = (count + 1) % 2; res.flag = true; // 喚醒當前線程
 res.notify(); } } } }

package com.hongmoshui.test03; class OutThread extends Thread { private Res res; public OutThread(Res res) { this.res = res; } @Override public void run() { while (true) { synchronized (res) { if (!res.flag) { try { res.wait(); } catch (Exception e) { e.printStackTrace(); } } System.out.println(res.userName + "--" + res.userSex); res.flag = false; res.notify(); } } } }

wait與sleep區別?

對於sleep()方法，咱們首先要知道該方法是屬於Thread類中的。而wait()方法，則是屬於Object類中的。

sleep()方法致使了程序暫停執行指定的時間，讓出cpu該其餘線程，可是他的監控狀態依然保持者，當指定的時間到了又會自動恢復運行狀態。

在調用sleep()方法的過程當中，線程不會釋放對象鎖。

而當調用wait()方法的時候，線程會放棄對象鎖，進入等待此對象的等待鎖定池，只有針對此對象調用notify()方法後本線程才進入對象鎖定池準備

獲取對象鎖進入運行狀態。

JDK1.5-Lock

在 jdk1.5 以後，併發包中新增了 Lock 接口(以及相關實現類)用來實現鎖功能，Lock 接口提供了與 synchronized 關鍵字相似的同步功能，但須要在使用時手動獲取鎖和釋放鎖。

Lock寫法

package com.hongmoshui.test04; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class TestLock { public static void main(String[] args) { Lock lock = new ReentrantLock(); lock.lock(); try { // 可能會出現線程安全的操做
 } finally { // 必定在finally中釋放鎖 // 也不能把獲取鎖在try中進行，由於有可能在獲取鎖的時候拋出異常
 lock.unlock(); } } }

Lock 接口與 synchronized 關鍵字的區別

Lock 接口能夠嘗試非阻塞地獲取鎖 當前線程嘗試獲取鎖。若是這一時刻鎖沒有被其餘線程獲取到，則成功獲取並持有鎖。
Lock 接口能被中斷地獲取鎖 與 synchronized 不一樣，獲取到鎖的線程可以響應中斷，當獲取到的鎖的線程被中斷時，中斷異常將會被拋出，同時鎖會被釋放。

Lock 接口在指定的截止時間以前獲取鎖，若是截止時間到了依舊沒法獲取鎖，則返回。

Condition用法

 Condition的功能相似於在傳統的線程技術中的,Object.wait()和Object.notify()的功能。

代碼

package com.hongmoshui.test04; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; class Res { public String userName; public String sex; public boolean flag = false; Lock lock = new ReentrantLock(); } class InputThread extends Thread { private Res res; Condition newCondition; public InputThread(Res res, Condition newCondition) { this.res = res; this.newCondition = newCondition; } @Override public void run() { int count = 0; while (true) { try { res.lock.lock(); if (res.flag) { try { newCondition.await(); } catch (Exception e) { } } if (count == 0) { res.userName = "洪墨水"; res.sex = "男"; } else { res.userName = "小紅"; res.sex = "女"; } count = (count + 1) % 2; res.flag = true; newCondition.signal(); } catch (Exception e) { } finally { res.lock.unlock(); } } } } class OutThrad extends Thread { private Res res; private Condition newCondition; public OutThrad(Res res, Condition newCondition) { this.res = res; this.newCondition = newCondition; } @Override public void run() { while (true) { try { res.lock.lock(); if (!res.flag) { try { newCondition.await(); } catch (Exception e) { } } System.out.println(res.userName + "," + res.sex); res.flag = false; newCondition.signal(); } catch (Exception e) { } finally { res.lock.unlock(); } } } } public class ThreadDemo01 { public static void main(String[] args) { Res res = new Res(); Condition newCondition = res.lock.newCondition(); InputThread inputThread = new InputThread(res, newCondition); OutThrad outThrad = new OutThrad(res, newCondition); inputThread.start(); outThrad.start(); } }

如何中止線程？

 中止線程思路

   1.  使用退出標誌，使線程正常退出，也就是當run方法完成後線程終止。

    2.  使用stop方法強行終止線程（這個方法不推薦使用，由於stop和suspend、resume同樣，也可能發生不可預料的結果）。

    3.  使用interrupt方法中斷線程。

代碼:

package com.hongmoshui.test04; class StopRunnable implements Runnable { private volatile boolean flag = true; public synchronized void run() { while (flag) { try { wait(); } catch (Exception e) { stopThread(); } System.out.println("thread:" + Thread.currentThread().getName() + " run over.."); } } /** * 中止線程 */
    public void stopThread() { flag = false; } } /** * 中止線程 */
public class StopThreadDemo { public static void main(String[] args) { StopRunnable stopRunnable = new StopRunnable(); Thread thread1 = new Thread(stopRunnable); Thread thread2 = new Thread(stopRunnable); thread1.start(); thread2.start(); int i = 0; while (true) { System.out.println("thread main.."); if (i == 300) { thread1.interrupt(); thread2.interrupt(); break; } i++; } } }