幹貨内容-線程的介紹和應用

1.程式 程序 線程

• 程式（program）：是為完成的特定任務，用某種語言編寫的一組指令的集合。簡單來說，就是我們寫的代碼。

• 程序：
• 程序是指運作中的程式，比如我們使用QQ，就啟動了一個程序，作業系統就會為該程序配置設定空間。當我們使用迅雷，又啟動了一個程序，作業系統将為迅雷配置設定新的記憶體空間。
• 程序是程式的一次執行過程，或是正在運作的一個程式。是動态過程：有它自身的産生、存在和消亡的過程。
• 線程：
• 線程是由程序建立的，是程序的一個實體
• 一個程序可以有多個線程，比如：用迅雷同時下載下傳多個檔案
• 其他相關概念：
• 單線程：同一時刻，隻允許執行一個線程
• 多線程：同一時刻，可以執行多個線程，比如：一個qq程序，可以同時打開多個聊天視窗；一個迅雷程序，可以同時下載下傳多個檔案。
• 并發：同一時刻，多個任務交替執行，造成一種“貌似同時”的錯覺，簡單地說，單核cpu實作的多任務就是并發
• 并行：同一時刻，多個任務同時執行。多核cpu可以實作并行。在電腦中也可能同時出現并發和并行的狀态。

例子：

package li.thread; public class CpuNum {    public static void main(String[] args) {         Runtime runtime = Runtime.getRuntime();        //擷取目前的電腦的cpu數量        int cpuNums = runtime.availableProcessors();        System.out.println("目前的CPU數量="+cpuNums);//目前的CPU數量=8     }}           

2.線程的基本使用

• 建立線程的兩種方式

在java中線程來使用有兩種方法：

1. 繼承Thread類，重寫run方法
2. 實作Runnable接口，重寫run方法

2.1繼承Thread建立線程

線程應用案例1-繼承Thread類：

1）請編寫程式，開啟一個線程，該線程每隔一秒，在控制台輸出 “喵喵，我是小貓咪”

2）對上題改進：當輸出80次“喵喵，我是小貓咪”時，結束該線程

3）使用JConsole監控線程執行情況，并畫出程式示意圖

package li.thread; //示範通過繼承Thread類建立線程public class Thread01 {    public static void main(String[] args) throws InterruptedException {                //建立一個Cat對象，可以當做線程來使用        Cat cat = new Cat();                cat.start();//啟動線程                //當main線程啟動一個子線程 Thread-0後，主線程不會阻塞，會繼續執行        //這時 主線程和子線程是交替執行        System.out.println("主線程繼續執行="+Thread.currentThread().getName());//主線程繼續執行=main        for (int i = 0; i < 60; i++) {            System.out.println("主線程 i="+i);            //讓主線程休眠            Thread.sleep(1000);        }    }} //1.當一個類繼承了Thread類，該類就可以當做一個線程使用//2.我們會重寫run方法，寫上自己的業務代碼//3.run Thread類實作了Runnable接口的run方法/*      @Override      public void run() {          if (target != null) {              target.run();          }      } */class Cat extends Thread {    @Override    public void run() {//重寫run方法，寫上自己的業務邏輯        int times = 0;        while (true) {            //該線程每隔1秒，在控制台輸出 “喵喵，我是小貓咪”            System.out.println("喵喵，我是小貓咪" + (++times)+" 線程名稱="+Thread.currentThread().getName());            //讓該線程休眠一秒            try {                Thread.sleep(1000);//機關為毫秒 try-catch快捷鍵：Ctrl+Alt+T            } catch (InterruptedException e) {                e.printStackTrace();            }            if (times == 80) {                break;//當times到80，退出while，這時線程也就退出了            }        }    }}           

3）使用JConsole監控線程執行情況，并畫出程式示意圖：

如下，在控制台點選run，運作程式，在程式運作時，點選Termial

在控制台輸入JConsole，回車。

點選本地程序，點選Thread01，點選下方連接配接按鈕：

在彈出視窗中點選不安全的連接配接按鈕：

在視窗中點選“線程”：

可以在左下角的線程小視窗中看到main線程和Thread-0線程在同時進行

等待一段時間，可以看到當run視窗的主線程 i = 60之後，main線程結束

結束前：

結束後：

當線程名稱=Thread-0輸出到80次時，雖然可以Thread-0還在左下角，但是實際上Thread-0線程已經結束了，整個程序随之結束。

程式示意圖：

注意：在多線程程式設計裡面，并不一定說主線程結束了，整個進行就結束了，等所有線程都結束了，程序才會結束。

2.2為什麼是start？

在2.1的例子中，主方法中定義了cat對象，該對象調用了start方法，start方法會去啟動一個線程，最終會執行Cat 類的run方法。

思考一個問題：既然最終都是要調用run方法，為什麼cat對象還要通過start方法對調用run呢？為什麼不直接調用？

答案： 首先通過 對象.run() 方法 可以執行方法，但是不是使用的多線程的方式，就是一個普通的方法，沒有真正地啟動一個線程。即這時候把run方法執行完畢，才能執行主方法剩下的語句。

如下圖：将cat.start();改為cat.run();之後的運作結果：

在run方法執行完之後才執行主方法剩下的語句

那麼在調用start方法時，整個過程到底是什麼樣子的？

點選start()方法：可以在start方法中看到一個start0（）方法：

點選start0( )方法：可以看到start0是一個本地方法，由 JVM調用，底層是c/c++實作。

再看看run（）方法的源碼：可以看到run方法隻是簡單的調用了實作類的run，沒有進行任何的多線程處理。

換而言之，Java中真正實作多線程的效果的是start0方法，而不是run方法

2.3實作Runnable建立線程

說明：

1. java是單繼承的，在某些情況下一個類可能已經繼承了某個父類，這時再用繼承Thread類方法來建立線程顯然不可能了。
2. java設計者們提供了另外一種方式來建立線程，就是通過實作Runnable接口來建立線程。

線程應用案例2-實作Runnable接口：

請編寫程式，該程式可以每隔一秒在控制台輸出“hi”，當輸出10次後，自動退出。請使用實作Runnable接口的方式實作。

package li.thread; //通過實作Runnable接口的方式來開發線程public class Thread02 {    public static void main(String[] args) {        Dog dog = new Dog();        //dog.start();這裡不能調用start方法         //建立Thread對象，把dog對象（實作Runnable）放入Thread對象中        Thread thread = new Thread(dog);        thread.start();     }}class Dog implements Runnable{//通過實作Runnable接口的方式開發線程    int count = 0 ;    @Override    public void run(){        while(true){            System.out.println("小狗汪汪叫..hi"+(++count)+Thread.currentThread().getName());            //休眠一秒            try {                Thread.sleep(1000);            } catch (InterruptedException e) {                e.printStackTrace();            }            if (count == 10) {                break;            }        }    }}           

因為Runnable接口隻有run方法，是以不能直接通過dog對象調用start方法

思考：為什麼将dog對象放入到thread對象之後，通過調用thread對象的start方法，就可以調用到dog的run方法了呢？

答案：這裡的底層使用了一個設計模式[代理模式中的靜态代理]，下面用代碼模拟實作Runnable接口 開發線程的機制

代碼模拟實作Runnable接口 開發線程的機制：

package li.thread; //通過實作Runnable接口的方式來開發線程public class Thread02 {    public static void main(String[] args) {                Tiger tiger = new Tiger();                //tiger之是以可以放進threadProxy裡，是因為tiger實作了Runnable接口        //ThreadProxy構造器的參數是Runnable類型，tiger賦給了target        ThreadProxy threadProxy = new ThreadProxy(tiger);         /*        start()方法調用start0()方法,start0()又會調用run方法，        run()方法傳回去調用target，判斷發現此時target不為空        接着就會進行動态綁定，運作類型為（Tiger），然後到Tiger類去執行run方法        */        threadProxy.start();    }} class Animal{}class Tiger extends Animal implements Runnable{     @Override    public void run() {        System.out.println("老虎嗷嗷叫...");    }} //線程代理類，模拟了一個極簡的Thread類class ThreadProxy implements Runnable {//可以将ThreadProxy當做是Thread     private Runnable target = null;//屬性，類型是Runnable     @Override    public void run() {        if (target != null) {            target.run();//動态綁定，運作類型（Tiger）        }     }     public ThreadProxy(Runnable target) {//接收一個實作了Runnable接口的對象，将它賦給target        this.target = target;    }     public void start(){        start0();//這個方法是最重要的，真正實作了多線程的方法（注意這裡隻是模拟，沒有真正實作）    }     public void start0(){        run();    }}           

動态綁定：動态綁定是指在執行期間（非編譯期）判斷所引用對象的實際類型，根據其實際的類型調用其相應的方法。程式運作過程中，把函數（或過程）調用與響應調用所需要的代碼相結合的過程稱為動态綁定。

2.4多線程執行

請編寫一個程式，建立兩個線程。一個線程每隔一秒輸出“hello world”，輸出10次後退出，另一個線程每隔1秒輸出“hi”，輸出5次後退出。要求使用實作Runnable接口的方式建立線程。

線程應用案例3-多線程執行：

package li.thread; public class Thread03 {    public static void main(String[] args) {        T1 t1 = new T1();        T2 t2 = new T2();         Thread thread1 = new Thread(t1);        Thread thread2 = new Thread(t2);         thread1.start();        thread2.start();        }} class T1 implements Runnable {    int count = 0;     @Override    public void run() {        while (true) {            //每隔1秒輸出“hello world”，輸出10次後退出            System.out.println("hello,world "+(++count));             try {                Thread.sleep(1000);            } catch (InterruptedException e) {                e.printStackTrace();            }            if (count == 10) {                break;            }        }    }} class T2 implements Runnable {    int count = 0;     @Override    public void run() {        while (true) {            //每隔1秒輸出“hi”，輸出5次後退出            System.out.println("hi "+(++count));            try {                Thread.sleep(1000);            } catch (InterruptedException e) {                e.printStackTrace();            }            if (count == 5) {                break;            }        }    }}           

3.繼承Thread和實作Runnable的差別

1. 從java的設計來看，通過繼承Thread或者實作Runnable接口本身來建立線程本質上沒有差別，從jdk幫助文檔我們可以看到Thread類本身就實作了Runnable接口
2. 實作Runnable接口方式更加适合多個線程共享一個資源的情況，并且避免了單繼承的限制，建議使用Runnable接口

3.1多線程售票問題

程式設計模拟三個售票視窗售票100張，分别使用繼承Thread類和實作Runnable接口的方法，并分析有什麼問題？

1.使用繼承Thread的方法：

package li.thread; //使用多線程，模拟三個視窗同時售票共100張public class SellTicket {    public static void main(String[] args) {         SellTicket01 sellTicket01 = new SellTicket01();        SellTicket01 sellTicket02 = new SellTicket01();        SellTicket01 sellTicket03 = new SellTicket01();         sellTicket01.start();//啟動售票線程        sellTicket02.start();//啟動售票線程        sellTicket03.start();//啟動售票線程    }} //1.使用繼承Thread類的方式class SellTicket01 extends Thread {     //多個對象共享同一個靜态成員變量（多個執行個體的static變量會共享同一塊記憶體區域）    private static int ticketNum = 100;//讓多個線程共享ticketNum     @Override    public void run() {        while (true) {             if (ticketNum <= 0) {                System.out.println("售票結束...");                break;            }             //休眠50毫秒,模拟            try {                Thread.sleep(50);            } catch (InterruptedException e) {                e.printStackTrace();            }             System.out.println("視窗：" + Thread.currentThread().getName() + "售出一張票 "                    + "剩餘票數：" + (--ticketNum));        }    }}           

一個顯然的問題是，剩餘票數竟然是負數！

原因是：每個線程都要進行票數判斷才能進行下一步操作，假設某時刻票數還剩2張，此時線程0判斷條件ticketNum <= 0不成立；于此同時，線程1線程2也同時進行了判斷，三者都通過了判斷，于是都認為此刻票數為2，都進行-1售票操作。于是三者結束後就會出現總票數為-1 的情況。

可以看到，造成票數超賣的主要原因是三個線程同時操作一個資源。

2.使用實作接口Runnable的方式：

package li.thread; //使用多線程，模拟三個視窗同時售票共100張public class SellTicket {    public static void main(String[] args) {         SellTicket02 sellTicket02 = new SellTicket02();        new Thread(sellTicket02).start();//第1個線程-視窗        new Thread(sellTicket02).start();//第2個線程-視窗        new Thread(sellTicket02).start();//第3個線程-視窗    }} class SellTicket02 implements Runnable {     private int ticketNum = 100;     @Override    public void run() {        while (true) {             if (ticketNum <= 0) {                System.out.println("售票結束...");                break;            }             //休眠50毫秒,模拟            try {                Thread.sleep(50);            } catch (InterruptedException e) {                e.printStackTrace();            }             System.out.println("視窗：" + Thread.currentThread().getName() + "售出一張票 "                    + "剩餘票數：" + (--ticketNum));        }    } }           

可以看到，實作接口Runnable的方式同樣發生了票數為負數的情況，原因與上面一緻，是由于多個線程同時操作一個資源而造成的。

要解決類似的問題，就要引入線程的同步和互斥的概念。該問題将在之後解決。

4.線程終止

• 基本說明：

1. 當線程完成任務後，會自動退出
2. 還可以通過使用變量來控制run方法退出的方式來停止線程，即通知方式

例子：

啟動一個線程t，要求在main線程中去停止線程t，請程式設計實作。

package li.thread.exit_; public class ThreadExit_ {    public static void main(String[] args) throws InterruptedException {        T t = new T();        t.start();         //如果希望main線程可以去控制 t1線程的終止，必須可以修改loop        //讓 t1退出run方法，進而終止 t1線程 -->稱為 通知方式         //讓主線程休眠 10秒，在通知 t1線程退出        System.out.println("主線程休眠10秒...");        Thread.sleep(10*1000);         t.setLoop(false);    }} class T extends Thread {    int count = 0;     //設定一個控制變量    private boolean loop = true;     @Override    public void run() {        while (loop) {            try {                Thread.sleep(50);            } catch (InterruptedException e) {                e.printStackTrace();            }            System.out.println("T 運作中..."+(++count));        }    }     public void setLoop(boolean loop) {        this.loop = loop;    }}           

可以用于一個線程通過變量控制另一個線程終止的情況。

5.線程常用方法

• 常用方法第一組：

1. setName //設定線程名稱，使之與參數name相同
2. getName //傳回該線程的名稱
3. start //使該線程開始執行；Java虛拟機底層調用該線程的start0()方法
4. run //調用線程對象run方法
5. setPriority //更改線程的優先級
6. getPriority // 擷取線程的優先級
7. sleep //在指定的毫秒數内讓目前正在執行的線程休眠（暫停執行）
8. interrupt //中斷線程

注意事項和細節：

• start方法底層會建立新的線程，調用run，run就是一個簡單的方法調用，不會啟動新的線程
• 線程優先級的範圍

• interrupt，中斷線程，但并沒有真正地結束線程。是以一般用于中斷正在休眠的線程
• sleep：線程的靜态方法，使目前線程休眠

例子1:

package li.thread.method; public class ThreadMethod01 {    public static void main(String[] args) throws InterruptedException {        //測試相關方法        T t = new T();        t.setName("jack");//設定線程的名稱        t.setPriority(Thread.MIN_PRIORITY);        t.start();//啟動子線程         //主線程列印5句hi，然後中斷子線程的休眠        for (int i = 0; i < 5; i++) {            Thread.sleep(1000);            System.out.println("hi" + i);        }         System.out.println(t.getName() + "線程的優先級=" + t.getPriority());        t.interrupt();//當執行到這裡的時候，就會中斷 t線程的休眠    }} class T extends Thread {//自定義的線程類     @Override    public void run() {        while (true) {//每隔5秒吃100個包子，然後休眠5秒，再吃...            for (int i = 0; i < 100; i++) {                //Thread.currentThread().getName()擷取目前線程的名稱                System.out.println(Thread.currentThread().getName() + "吃包子~~~" + i);            }            try {                System.out.println(Thread.currentThread().getName() + "休眠中~~~");                sleep(20000);//休眠20秒            } catch (InterruptedException e) {                //當該線程執行到一個interrupt方法時，就會catch一個異常，可以加入自己的業務代碼                //InterruptedException是捕獲到一個中斷異常                System.out.println(Thread.currentThread().getName() + "被interrupt了");            }        }    }}           

• 常用方法第二組：

1. yield：線程的禮讓。讓出cpu，讓其他線程執行，但禮讓的時間不确定，是以也不一定禮讓成功。
2. join：線程的插隊。插隊的線程一旦插隊成功，則肯定先執行完插入的線程的所有任務

例子2：建立一個子線程，每個1秒輸出hello，輸出20次；主線程每隔1秒輸出hi，輸出20次。要求：兩個線程同時執行，當主線程輸出5次後，就讓子線程運作完畢，主線程再繼續。（join）

package li.thread.method; public class ThreadMethod02 {    public static void main(String[] args) throws InterruptedException {        T2 t2 = new T2();        t2.start();         for (int i = 0; i <=20; i++) {            Thread.sleep(1000);            System.out.println("主線程吃了 "+i+" 個包子");            if (i == 5) {                System.out.println("主線程讓子線程先吃包子...");                t2.join();//相當于讓 t2線程先執行完畢                //Thread.yield();//如果這裡是yield，不一定會禮讓成功                System.out.println("主線程接着吃包子...");            }        }    }} class T2 extends Thread {    int loop = 0;     @Override    public void run() {        for (int i = 0; i <= 20; i++) {            try {                Thread.sleep(1000);            } catch (InterruptedException e) {                e.printStackTrace();            }            System.out.println("子線程吃了 "+i+" 個包子");        }    }}           

• 課堂練習：主線程每隔一秒輸出hi，一共十次當輸出到5次時，啟動一個子線程（要求實作Runnable），該子線程每隔1s輸出hello，等該宣稱輸出10次後，退出主線程繼續輸出hi，直到主線程退出

package li.thread.method; public class ThreadMethod03 {    public static void main(String[] args) throws InterruptedException {         Thread thread = new Thread(new T3());        for (int i = 0; i <= 10; i++) {            Thread.sleep(1000);            System.out.println("hi" + i);            if (i == 5) {                thread.start();//啟動子線程                thread.join();//将子線程先執行            }        }    }} class T3 implements Runnable {     @Override    public void run() {        for (int i = 0; i <= 10; i++) {            try {                Thread.sleep(1000);            } catch (InterruptedException e) {                e.printStackTrace();            }            System.out.println("hello" + i);        }    }}           

線程基礎02

3.繼承Thread和實作Runnable的差別

1. 從java的設計來看，通過繼承Thread或者實作Runnable接口本身來建立線程本質上沒有差別，從jdk幫助文檔我們可以看到Thread類本身就實作了Runnable接口
2. 實作Runnable接口方式更加适合多個線程共享一個資源的情況，并且避免了單繼承的限制，建議使用Runnable接口

3.1多線程售票問題

程式設計模拟三個售票視窗售票100張，分别使用繼承Thread類和實作Runnable接口的方法，并分析有什麼問題？

1.使用繼承Thread的方法：

package li.thread; //使用多線程，模拟三個視窗同時售票共100張public class SellTicket {    public static void main(String[] args) {         SellTicket01 sellTicket01 = new SellTicket01();        SellTicket01 sellTicket02 = new SellTicket01();        SellTicket01 sellTicket03 = new SellTicket01();         sellTicket01.start();//啟動售票線程        sellTicket02.start();//啟動售票線程        sellTicket03.start();//啟動售票線程    }} //1.使用繼承Thread類的方式class SellTicket01 extends Thread {     //多個對象共享同一個靜态成員變量（多個執行個體的static變量會共享同一塊記憶體區域）    private static int ticketNum = 100;//讓多個線程共享ticketNum     @Override    public void run() {        while (true) {             if (ticketNum <= 0) {                System.out.println("售票結束...");                break;            }             //休眠50毫秒,模拟            try {                Thread.sleep(50);            } catch (InterruptedException e) {                e.printStackTrace();            }             System.out.println("視窗：" + Thread.currentThread().getName() + "售出一張票 "                    + "剩餘票數：" + (--ticketNum));        }    }}           

一個顯然的問題是，剩餘票數竟然是負數！

原因是：每個線程都要進行票數判斷才能進行下一步操作，假設某時刻票數還剩2張，此時線程0判斷條件ticketNum <= 0不成立；于此同時，線程1線程2也同時進行了判斷，三者都通過了判斷，于是都認為此刻票數為2，都進行-1售票操作。于是三者結束後就會出現總票數為-1 的情況。

可以看到，造成票數超賣的主要原因是三個線程同時操作一個資源。

2.使用實作接口Runnable的方式：

package li.thread; //使用多線程，模拟三個視窗同時售票共100張public class SellTicket {    public static void main(String[] args) {         SellTicket02 sellTicket02 = new SellTicket02();        new Thread(sellTicket02).start();//第1個線程-視窗        new Thread(sellTicket02).start();//第2個線程-視窗        new Thread(sellTicket02).start();//第3個線程-視窗    }} class SellTicket02 implements Runnable {     private int ticketNum = 100;     @Override    public void run() {        while (true) {             if (ticketNum <= 0) {                System.out.println("售票結束...");                break;            }             //休眠50毫秒,模拟            try {                Thread.sleep(50);            } catch (InterruptedException e) {                e.printStackTrace();            }             System.out.println("視窗：" + Thread.currentThread().getName() + "售出一張票 "                    + "剩餘票數：" + (--ticketNum));        }    } }           

可以看到，實作接口Runnable的方式同樣發生了票數為負數的情況，原因與上面一緻，是由于多個線程同時操作一個資源而造成的。

要解決類似的問題，就要引入線程的同步和互斥的概念。該問題将在之後解決。

4.線程終止

• 基本說明：

1. 當線程完成任務後，會自動退出
2. 還可以通過使用變量來控制run方法退出的方式來停止線程，即通知方式

例子：

啟動一個線程t，要求在main線程中去停止線程t，請程式設計實作。

package li.thread.exit_; public class ThreadExit_ {    public static void main(String[] args) throws InterruptedException {        T t = new T();        t.start();         //如果希望main線程可以去控制 t1線程的終止，必須可以修改loop        //讓 t1退出run方法，進而終止 t1線程 -->稱為 通知方式         //讓主線程休眠 10秒，在通知 t1線程退出        System.out.println("主線程休眠10秒...");        Thread.sleep(10*1000);         t.setLoop(false);    }} class T extends Thread {    int count = 0;     //設定一個控制變量    private boolean loop = true;     @Override    public void run() {        while (loop) {            try {                Thread.sleep(50);            } catch (InterruptedException e) {                e.printStackTrace();            }            System.out.println("T 運作中..."+(++count));        }    }     public void setLoop(boolean loop) {        this.loop = loop;    }}           

可以用于一個線程通過變量控制另一個線程終止的情況。

5.線程常用方法

• 常用方法第一組：

1. setName //設定線程名稱，使之與參數name相同
2. getName //傳回該線程的名稱
3. start //使該線程開始執行；Java虛拟機底層調用該線程的start0()方法
4. run //調用線程對象run方法
5. setPriority //更改線程的優先級
6. getPriority // 擷取線程的優先級
7. sleep //在指定的毫秒數内讓目前正在執行的線程休眠（暫停執行）
8. interrupt //中斷線程

注意事項和細節：

• start方法底層會建立新的線程，調用run，run就是一個簡單的方法調用，不會啟動新的線程
• 線程優先級的範圍

• interrupt，中斷線程，但并沒有真正地結束線程。是以一般用于中斷正在休眠的線程
• sleep：線程的靜态方法，使目前線程休眠

例子1:

package li.thread.method; public class ThreadMethod01 {    public static void main(String[] args) throws InterruptedException {        //測試相關方法        T t = new T();        t.setName("jack");//設定線程的名稱        t.setPriority(Thread.MIN_PRIORITY);        t.start();//啟動子線程         //主線程列印5句hi，然後中斷子線程的休眠        for (int i = 0; i < 5; i++) {            Thread.sleep(1000);            System.out.println("hi" + i);        }         System.out.println(t.getName() + "線程的優先級=" + t.getPriority());        t.interrupt();//當執行到這裡的時候，就會中斷 t線程的休眠    }} class T extends Thread {//自定義的線程類     @Override    public void run() {        while (true) {//每隔5秒吃100個包子，然後休眠5秒，再吃...            for (int i = 0; i < 100; i++) {                //Thread.currentThread().getName()擷取目前線程的名稱                System.out.println(Thread.currentThread().getName() + "吃包子~~~" + i);            }            try {                System.out.println(Thread.currentThread().getName() + "休眠中~~~");                sleep(20000);//休眠20秒            } catch (InterruptedException e) {                //當該線程執行到一個interrupt方法時，就會catch一個異常，可以加入自己的業務代碼                //InterruptedException是捕獲到一個中斷異常                System.out.println(Thread.currentThread().getName() + "被interrupt了");            }        }    }}           

• 常用方法第二組：

1. yield：線程的禮讓。讓出cpu，讓其他線程執行，但禮讓的時間不确定，是以也不一定禮讓成功。
2. join：線程的插隊。插隊的線程一旦插隊成功，則肯定先執行完插入的線程的所有任務

例子2：建立一個子線程，每個1秒輸出hello，輸出20次；主線程每隔1秒輸出hi，輸出20次。要求：兩個線程同時執行，當主線程輸出5次後，就讓子線程運作完畢，主線程再繼續。（join）

package li.thread.method; public class ThreadMethod02 {    public static void main(String[] args) throws InterruptedException {        T2 t2 = new T2();        t2.start();         for (int i = 0; i <=20; i++) {            Thread.sleep(1000);            System.out.println("主線程吃了 "+i+" 個包子");            if (i == 5) {                System.out.println("主線程讓子線程先吃包子...");                t2.join();//相當于讓 t2線程先執行完畢                //Thread.yield();//如果這裡是yield，不一定會禮讓成功                System.out.println("主線程接着吃包子...");            }        }    }} class T2 extends Thread {    int loop = 0;     @Override    public void run() {        for (int i = 0; i <= 20; i++) {            try {                Thread.sleep(1000);            } catch (InterruptedException e) {                e.printStackTrace();            }            System.out.println("子線程吃了 "+i+" 個包子");        }    }}           

• 課堂練習：主線程每隔一秒輸出hi，一共十次當輸出到5次時，啟動一個子線程（要求實作Runnable），該子線程每隔1s輸出hello，等該宣稱輸出10次後，退出主線程繼續輸出hi，直到主線程退出

package li.thread.method; public class ThreadMethod03 {    public static void main(String[] args) throws InterruptedException {         Thread thread = new Thread(new T3());        for (int i = 0; i <= 10; i++) {            Thread.sleep(1000);            System.out.println("hi" + i);            if (i == 5) {                thread.start();//啟動子線程                thread.join();//将子線程先執行            }        }    }} class T3 implements Runnable {     @Override    public void run() {        for (int i = 0; i <= 10; i++) {            try {                Thread.sleep(1000);            } catch (InterruptedException e) {                e.printStackTrace();            }            System.out.println("hello" + i);        }    }}           

6.使用者線程和守護線程

1. 使用者線程：也叫工作線程，當線程的任務執行完或者通知方法結束。平時用到的普通線程均是使用者線程，當在Java程式中建立一個線程，它就被稱為使用者線程
2. 守護線程（Daemon）：一般是為工作線程服務的，當所有的使用者線程結束，守護線程自動結束
3. 常見的守護線程：垃圾回收機制

例子1：如何将一個線程設定成守護線程

package li.thread.method; public class ThreadMethodExercise {    public static void main(String[] args) throws InterruptedException {                MyDaemonThread myDaemonThread = new MyDaemonThread();                //如果我們希望當主線程結束後，子線程自動結束，隻需要将子線程設定為守護線程        myDaemonThread.setDaemon(true);                myDaemonThread.start();                for (int i = 1; i <= 10; i++) {//main線程            System.out.println("悟空在前方打妖精...");            Thread.sleep(1000);        }    }} class MyDaemonThread extends Thread {    @Override    public void run() {        for (; ; ) {//無限循環            try {                Thread.sleep(1000);            } catch (InterruptedException e) {                e.printStackTrace();            }            System.out.println("八戒收拾東西回高老莊...");        }    }}           

7.線程的生命周期

• JDK中用Thread.State枚舉表示了線程的幾種狀态：

例子

package li.thread.state; public class ThreadState_ {    public static void main(String[] args) throws InterruptedException {        T t = new T();        System.out.println(t.getName() + "狀态 " + t.getState());        t.start();        while (t.getState() != Thread.State.TERMINATED) {            System.out.println(t.getName() + "狀态 " + t.getState());            Thread.sleep(1000);        }         System.out.println(t.getName() + "狀态 " + t.getState());     }} class T extends Thread {    @Override    public void run() {        for (int i = 0; i < 10; i++) {            System.out.println("hi" + i);            try {                Thread.sleep(1000);            } catch (InterruptedException e) {                e.printStackTrace();            }        }    }}           

8.線程同步機制

• 線程同步機制

1. 在多線程程式設計中，一些敏感資料不允許被多個線程同時通路，此時就使用同步通路技術，保證資料在任何同一時刻，最多有一個線程通路，以保證資料的完整性。
2. 也可以了解為：線程同步，即當有一個線程在對記憶體進行操作時，其他線程都不可以對這個記憶體位址進行操作，直到該線程完成操作，其他線程才能對該記憶體位址進行操作。

• 同步具體方法--Synchronized

1. 同步代碼塊
2. synchronized(對象){//得到對象的鎖，才能操作同步代碼 //需要被同步的代碼}
3. synchronized還可以放在方法聲明中，表示整個方法為同步方法
4. public synchronized void m(String name){ //需要被同步的代碼}
5. 就好像某個小夥伴上廁所之前先把門關上（上鎖），完事之後再出來（解鎖），那麼其他小夥伴就可以再使用廁所了

例子：使用synchronized解決3.1售票問題

package li.thread.syn; //使用多線程，模拟三個視窗同時售票共100張public class SynSellTicket {    public static void main(String[] args) {         SellTicket03 sellTicket03 = new SellTicket03();        new Thread(sellTicket03).start();//第1個線程-視窗        new Thread(sellTicket03).start();//第2個線程-視窗        new Thread(sellTicket03).start();//第3個線程-視窗    }} //實作接口方式，使用synchronized實作線程同步class SellTicket03 implements Runnable {     private int ticketNum = 100;    private boolean loop = true;//控制run方法變量     public synchronized void sell() {//同步方法，在在同一時刻，隻能有一個線程來執行run方法        if (ticketNum <= 0) {            System.out.println("售票結束...");            loop = false;            return;        }        //休眠50毫秒,模拟        try {            Thread.sleep(50);        } catch (InterruptedException e) {            e.printStackTrace();        }        System.out.println("視窗：" + Thread.currentThread().getName() + "售出一張票 "                + "剩餘票數：" + (--ticketNum));    }     @Override    public void run() {        while (loop) {            sell();//sell方法是一個同步方法        }    }}           

8.1互斥鎖

• 基本介紹

1. Java語言中，引入了對象互斥鎖的概念，來保證共享資料操作的完整性
2. 每一個對象都對應于一個可稱為“互斥鎖”的标記，這個标記用來保證在任一時刻，隻能有一個線程通路該對象
3. 關鍵字synchronized來與對象的互斥鎖聯系。當某個對象用synchronized修飾時，表明該對象在任一時刻隻能有一個線程通路
4. 同步的局限性：導緻程式的執行效率降低
5. 非靜态的同步方法，鎖可以是this（目前對象），也可以是其他對象（要求鎖的是同一個對象）
6. 同步方法（靜态的）的鎖為目前類本身（類.class）

synchronized實作同步的基礎：Java中的每一個對象都可以作為鎖。

具體表現為以下3種形式。

對于普通同步方法，鎖是目前執行個體對象。

對于靜态同步方法，鎖是目前類的Class對象。

對于同步方法塊，鎖是Synchonized括号裡配置的對象。

• 注意事項和細節：同步方法如果沒有使用static修飾：預設鎖對象為this如果方法使用static修飾，預設鎖對象：目前類.class實作的落地步驟：需要先分析上鎖的代碼選擇同步代碼塊或者同步方法要求多個線程的鎖對象為同一個

package li.thread.syn; //使用多線程，模拟三個視窗同時售票共100張public class SynSellTicket {    public static void main(String[] args) {         SellTicket03 sellTicket03 = new SellTicket03();        new Thread(sellTicket03).start();//第1個線程-視窗        new Thread(sellTicket03).start();//第2個線程-視窗        new Thread(sellTicket03).start();//第3個線程-視窗    }} //實作接口方式，使用synchronized實作線程同步class SellTicket03 implements Runnable {     private int ticketNum = 100;    private boolean loop = true;//控制run方法變量    Object object = new Object();     //1.public synchronized static void m1(){}的鎖加在SellTicket03.class    public synchronized static void m1(){}    //2.如果在靜态方法中，要實作一個同步代碼塊則應該這樣寫：（原因是靜态方法适合類一起加載的，靜态方法不能使用this）    public static void m2(){        synchronized (SellTicket03.class){            System.out.println("m2");        }    }     // public synchronized void sell() {}就是一個同步方法。這時，鎖在this對象    //也可以在代碼塊上寫synchronized，同步代碼塊,互斥鎖還是在this對象    public /*synchronized*/void sell() {//同步方法        synchronized (/*this*/object) {//如果是new Object就不是同一個對象            if (ticketNum <= 0) {                System.out.println("售票結束...");                loop = false;                return;            }            //休眠50毫秒,模拟            try {                Thread.sleep(50);            } catch (InterruptedException e) {                e.printStackTrace();            }            System.out.println("視窗：" + Thread.currentThread().getName() + "售出一張票 "                    + "剩餘票數：" + (--ticketNum));        }    }     @Override    public void run() {        while (loop) {            sell();//sell方法是一個同步方法        }    }}           

8.2線程的死鎖

• 基本介紹：

多個線程都占用了對方的鎖資源，但不肯相讓，導緻了死鎖。

在程式設計中一定要避免死鎖的發生。

例子：

package li.thread.syn; //模拟線程死鎖public class DeadLock_ {    public static void main(String[] args) {        //模拟死鎖現象        DeadLockDemo A = new DeadLockDemo(true);        DeadLockDemo B = new DeadLockDemo(false);        A.setName("A線程");        B.setName("B線程");        A.start();        B.start();    }} class DeadLockDemo extends Thread {    static Object o1 = new Object();//保證多線程，共享一個對象，這裡使用static    static Object o2 = new Object();    boolean flag;     public DeadLockDemo(boolean flag) {//構造器        this.flag = flag;    }     @Override    public void run() {        //下面業務邏輯的分析        //1.如果flag為true，線程就會先得到/持有 o1對象鎖，然後嘗試去擷取o2對象鎖        //2.如果線程A得不到o2對象鎖，就會Blocked        //3.如果flag為false，線程B就會先得到/持有 o2對象鎖，然後嘗試去擷取o1對象鎖        //4.如果線程B得不到o1對象鎖，就會Blocked        if (flag) {            synchronized (o1) {//對象互斥鎖，下面就是同步代碼                System.out.println(Thread.currentThread().getName() + "進入1");                synchronized (o2) {//這裡獲得li對象的監視權                    System.out.println(Thread.currentThread().getName() + "進入2");                }            }        } else {            synchronized (o2) {                System.out.println(Thread.currentThread().getName() + "進入3");                synchronized (o1) {//這裡獲得li對象的監視權                    System.out.println(Thread.currentThread().getName() + "進入4");                }            }        }    }}           

如下圖：兩個線程卡住了

8.3釋放鎖

下面操作會釋放鎖：

1. 目前線程的同步方法、同步代碼塊執行結束
2. 目前線程在同步代碼塊、同步方法中遇到break、return
3. 目前線程在同步代碼塊、同步方法中出現了未處理的Error或者Exception，導緻異常結束
4. 目前線程在同步代碼塊、同步方法中執行了線程對象的wait()方法，目前線程暫停，并釋放鎖

下面的操作不會釋放鎖：

1. 線程執行同步代碼塊或同步方法時，程式調用Thread.sleep()、Thread.yield()方法暫停目前線程的執行，不會釋放鎖
2. 線程執行同步代碼塊時，其他線程調用了該線程的suspend()方法将該線程挂起，該線程不會釋放鎖。

提示：應盡量避免使用suspend()和resume()來控制線程，這兩個方法不再推薦使用

9.本章作業

9.1線程HomeWork01

（1）在main方法中啟動兩個線程

（2）第一個線程循環随機列印100以内的整數

（3）直到第二個線程從鍵盤讀取了“Q”指令

練習：

package li.thread.syn.homework; import java.util.Scanner; //（1）在main方法中啟動兩個線程public class ThreadHomeWork01 {     public static void main(String[] args) {         A a = new A();        B b = new B(a);//注意把a對象傳入b構造器中         a.start();        b.start();    }} //建立A線程類class A extends Thread {    private boolean loop = true;     @Override    public void run() {        while (loop) {            System.out.println((int) (Math.random() * 100 + 1));            try {                Thread.sleep(1000);            } catch (InterruptedException e) {                e.printStackTrace();            }        }        System.out.println("a線程退出...");    }     public void setLoop(boolean loop) {        this.loop = loop;    }} //建立B線程類class B extends Thread {    private A a;    Scanner scanner = new Scanner(System.in);     public B(A a) {        this.a = a;    }     @Override    public void run() {        while (true) {            //接到使用者輸入            System.out.println("請輸入你的指令(Q)表示退出");            char key = scanner.next().toUpperCase().charAt(0);            if (key == 'Q') {                //以通知的方式結束a線程                a.setLoop(false);                System.out.println("b線程退出...");                break;            }        }    }}           

9.2線程線程HomeWork02

（1）有兩個使用者分别從同一張卡上取錢（總額10000）

（2）每次都取1000，當餘額不足時，就不能取款了

（3）不能出現超取現象==>線程同步問題

易錯點：關于互斥鎖的了解

對于普通同步方法，鎖是目前執行個體對象。

對于靜态同步方法，鎖是目前類的Class對象。

對于同步方法塊，鎖是Synchonized括号裡配置的對象

package li.thread.syn.homework; public class ThreadHomeWork02 {    public static void main(String[] args) {        T t = new T();        Thread thread1 = new Thread(t);        Thread thread2 = new Thread(t);        thread1.setName("t1");        thread2.setName("t2");        thread1.start();        thread2.start();    }} class T implements Runnable {    private int money = 10000;     @Override    public void run() {        while (true) {//while不要放到同步代碼塊裡面            //1.使用了synchronized實作線程同步            //2.當多個線程執行到這裡的時候就會去争奪 this對象鎖            //3.哪個線程争奪到（擷取）this對象鎖，就執行synchronized代碼塊            //4.争奪不到this對象鎖，就Blocked，準備繼續争奪            //5.this對象鎖是非公平鎖            synchronized (this) {                if (money <= 0) {                    System.out.println("餘額不足...");                    break;                }                money -= 1000;                System.out.println(Thread.currentThread().getName() + "取出了1000元" + " 目前餘額為：" + money);            }            try {                Thread.sleep(1000);            } catch (InterruptedException e) {                e.printStackTrace();            }        }    }}