Java多執行緒詳解總結

一、基本概念

程式(program): 是為完成特定任務、用某種語言編寫的一組指令的集合。即指一 段靜態的程式碼，靜態物件。

程式(process):是程式的一次執行過程，或是正在執行的一個程式。是一個動態 的過程：有它自身的產生、存在和消亡的過程。——生命週期

• 執行中的QQ，執行中的MP3播放器
• 程式是靜態的，程式是動態的
• 程式作為資源分配的單位，系統在執行時會為每個程式分配不同的記憶體區域

執行緒(thread):程式可進一步細化為執行緒，是一個程式內部的一條執行路徑。

• 若一個程式同一時間並行執行多個執行緒，就是支援多執行緒的
• 執行緒作為排程和執行的單位，每個執行緒擁有獨立的執行棧和程式計數器(pc)，執行緒切換的開 銷小
• 一個程式中的多個執行緒共享相同的記憶體單元/記憶體地址空間->它們從同一堆中分配物件，可以 訪問相同的變數和物件。這就使得執行緒間通訊更簡便、高效。但多個執行緒操作共享的系統資 源可能就會帶來安全的隱患。

1. 單核CPU和多核CPU的理解

• 單核CPU，其實是一種假的多執行緒，因為在一個時間單元內，也只能執行一個執行緒 的任務。例如：雖然有多車道，但是收費站只有一個工作人員在收費，只有收了費 才能通過，那麼CPU就好比收費人員。如果有某個人不想交錢，那麼收費人員可以 把他“掛起”（晾著他，等他想通了，準備好了錢，再去收費）。但是因為CPU時 間單元特別短，因此感覺不出來。
• 如果是多核的話，才能更好的發揮多執行緒的效率。（現在的伺服器都是多核的）
• 一個Java應用程式java.exe，其實至少有三個執行緒：main()主執行緒，gc() 垃圾回收執行緒，異常處理執行緒。當然如果發生異常，會影響主執行緒。

2. 並行與併發

並行：多個CPU同時執行多個任務。比如：多個人同時做不同的事

併發：一個CPU(採用時間片)同時執行多個任務。比如：秒殺、多個人做同一件事

3. 使用多執行緒的優點

• 提高應用程式的響應。對圖形化介面更有意義，可增強使用者體驗。
• 提高計算機系統CPU的利用率
• 改善程式結構。將既長又複雜的程式分為多個執行緒，獨立執行，利於理解和 修改

4. 何時需要多執行緒

• 程式需要同時執行兩個或多個任務
• 程式需要實現一些需要等待的任務時，如使用者輸入、檔案讀寫
  操作、網路操作、搜尋等
• 需要一些後臺執行的程式時

二、多執行緒的實現

在Java之中，如果要想實現多執行緒的程式，那麼就必須依靠一個執行緒的主體類（就好比主類的概念一樣，表示的是一個執行緒的主類），但是這個執行緒的主體類在定義的時候也需要有一些特殊的要求，這個類可以繼承Thread類或實現Runnable介面來完成定義。

1. 繼承Thread類

• 定義子類繼承Thread類
• 子類中重寫Thread類中的run方法
• 建立Thread子類物件，即建立了執行緒物件
• 呼叫執行緒物件start方法：1啟動執行緒，2呼叫run方法

要想啟動執行緒必須依靠Thread類的start()方法執行，執行緒啟動之後會預設呼叫了run()方法、

package com.atguigu.java;

/**
 * @author MD
 * @create 2020-07-10 16:58
 */

// 1.
class Mythread extends Thread{

    // 2.
    @Override
    public void run() {
        for (int i = 0; i < 50 ; i++) {
            if (i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":"+i);
            }
        }
    }
}

public class ThreadTest {

    public static void main(String[] args) {
        // 3.
        Mythread mythread = new Mythread();
        //4.
        mythread.start();
        
        // 這個仍然是在main執行緒中執行
        for (int i = 0; i < 50 ; i++) {
            if (i % 2 != 0){
                System.out.println(Thread.currentThread().getName() + ":"+i);
            }
        }
    }
}
/*
注意：
1. 如果自己手動呼叫run()方法，那麼就只是普通方法，沒有啟動多執行緒模式。
2. run()方法由JVM呼叫，什麼時候呼叫，執行的過程控制都有作業系統的CPU排程決定。
3. 想要啟動多執行緒，必須呼叫start方法。
4. 一個執行緒物件只能呼叫一次start()方法啟動，如果重複呼叫了，則將丟擲以上 的異常“IllegalThreadStateException”
*/

// 也可以使用匿名內部類簡單的寫
new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    if (i % 2 == 0)
                        System.out.println(Thread.currentThread().getName() + ":" + i);
                }
            }
        }.start();

2. Thread類的有關方法

• void start(): 啟動執行緒，並執行物件的run()方法
• run(): 執行緒在被排程時執行的操作
• String getName(): 返回執行緒的名稱
• void setName(String name):設定該執行緒名稱
• static Thread currentThread(): 返回當前執行緒。在Thread子類中就 是this，通常用於主執行緒和Runnable實現類
• static void yield()：執行緒讓步
  • 暫停當前正在執行的執行緒，把執行機會讓給優先順序相同或更高的執行緒
  • 若佇列中沒有同優先順序的執行緒，忽略此方法
• join() ：當某個程式執行流中呼叫其他執行緒的 join() 方法時，呼叫執行緒將 被阻塞，直到 join() 方法加入的 join 執行緒執行完為止
  • 低優先順序的執行緒也可以獲得執行
• static void sleep(long millis)：(指定時間:毫秒)
  • 令當前活動執行緒在指定時間段內放棄對CPU控制,使其他執行緒有機會被執行,時間到後 重排隊。
  • 丟擲InterruptedException異常

/**
 * 測試Thread中常用的方法
 * 1. start():啟動當前程式，並且呼叫當前程式的run()方法
 * 2. run()：通常需要重寫Thread類中的此方法，將建立的執行緒要執行的操作宣告在這個方法中
 * 3. currentThread(): 靜態方法，返回當前程式碼的執行緒
 * 4. getName():獲取當前執行緒的名字
 * 5. setName()： 設定當前執行緒的名字
 * 6. yield(): 釋放當前cpu的執行權
 * 7. join(): 線上程A中呼叫執行緒B的join()，此時執行緒A就進入到了阻塞的狀態，直到執行緒B執行完成，執行緒A才結束阻塞狀態
 * 8. sleep(): 讓當前的執行緒睡眠指定的時間
 *
 * @author MD
 * @create 2020-07-10 20:34
 */

class Method extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0)
                System.out.println(Thread.currentThread().getName() + ":" + i);

            if (i % 4 == 0)
                yield();

        }
    }


}

public class ThreadMethodTest {
    public static void main(String[] args) {
        Method method = new Method();
        method.setName("執行緒一：");
        method.start();

        // 給主執行緒命名
        Thread.currentThread().setName("主執行緒：");
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0)
                System.out.println(Thread.currentThread().getName() + ":" + i);

            if (i == 10) {
                try {
                    method.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }
    }
}

3. 執行緒的優先順序

執行緒的優先順序等級

• MAX_PRIORITY：10
• MIN _PRIORITY：1
• NORM_PRIORITY：5 預設的 main()

方法：

• getPriority() ：返回執行緒優先值
• setPriority(int newPriority) ：改變執行緒的優先順序

注意：

• 執行緒建立時繼承父執行緒的優先順序
• 低優先順序只是獲得排程的概率低，並非一定是在高優先順序執行緒之後才被呼叫

        mythread.setPriority(Thread.MAX_PRIORITY);
        mythread.start();

        // 設定主執行緒的優先順序，最低
        Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
     

4. 實現Runnable介面

• 定義子類，實現Runnable介面。
• 子類中重寫Runnable介面中的run方法。
• 通過Thread類含參構造器建立執行緒物件。
• 將Runnable介面的子類物件作為實際引數傳遞給Thread類的構造器中。
• 呼叫Thread類的start方法：開啟執行緒，呼叫Runnable子類介面的run方法

package com.atguigu.java;

/**
 * @author MD
 * @create 2020-07-10 21:53
 */

// 1. 定義子類，實現Runnable介面。
class Mthread implements Runnable{

//   2. 子類中重寫Runnable介面中的run方法。
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0)
                System.out.println(Thread.currentThread().getName() +":"+i);
        }
    }
}

public class ThreadTest1 {
    public static void main(String[] args) {
        // 3. 通過Thread類含參構造器建立執行緒物件。
        Mthread mthread = new Mthread();
        // 4. 將Runnable介面的子類物件作為實際引數傳遞給Thread類的構造器中。
        Thread t1 = new Thread(mthread);
        //5. 呼叫Thread類的start方法：開啟執行緒，呼叫Runnable子類介面的run方法
        
        t1.start();


        // 再啟動一個執行緒
        Thread t2 = new Thread(mthread);
        t2.start();

    }
}

5. 比較建立執行緒的兩種方式

• 多執行緒的兩種實現方式都需要一個執行緒的主類，而這個類可以實現Runnable介面或繼承Thread類，不管使用何種方式都必須在子類之中覆寫run()方法，此方法為執行緒的主方法；
• Thread類是Runnable介面的子類，而且使用Runnable介面可以避免單繼承侷限，以及更加方便的實現資料共享的概念 ,開發中常用

class MyThread implements Runnable {	
    @Override
	public void run() { // 執行緒的主方法
		// 執行緒操作方法
	}
}
MyThread mt = new MyThread();
new Thread(mt).start();

// 
class MyThread extends Thread { 
	@Override
	public void run() { // 執行緒的主方法
		// 執行緒操作方法
	}
}
MyThread mt = new MyThread();
mt.start();

三、執行緒的生命週期

要想實現多執行緒，必須在主執行緒中建立新的執行緒物件。Java語言使用Thread類 及其子類的物件來表示執行緒，在它的一個完整的生命週期中通常要經歷如下的五 種狀態：

• 新建： 當一個Thread類或其子類的物件被宣告並建立時，新生的執行緒物件處於新建 狀態
• 就緒：處於新建狀態的執行緒被start()後，將進入執行緒佇列等待CPU時間片，此時它已 具備了執行的條件，只是沒分配到CPU資源
• 執行：當就緒的執行緒被排程並獲得CPU資源時,便進入執行狀態， run()方法定義了線 程的操作和功能
• 阻塞：在某種特殊情況下，被人為掛起或執行輸入輸出操作時，讓出 CPU 並臨時中 止自己的執行，進入阻塞狀態
• 死亡：執行緒完成了它的全部工作或執行緒被提前強制性地中止或出現異常導致結束

四、執行緒的同步與死鎖

多個執行緒執行的不確定性引起執行結果的不穩定

多個執行緒對賬本的共享，會造成操作的不完整性，會破壞資料

1. 同步問題

模擬火車站售票程式，開啟三個視窗售票

package com.atguigu.java;

/**
 * @author MD
 * @create 2020-07-11 9:25
 */
class Window implements Runnable{

    private int ticket = 100;
    @Override
    public void run() {
        while (true){
			try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (ticket > 0){
                System.out.println(Thread.currentThread().getName() +"：賣票，票號為" + ticket);
                ticket--;
            }else {
                break;
            }
        }
    }
}

public class WindowTest {

    public static void main(String[] args) {
        Window w = new Window();

        new Thread(w, "視窗1").start();
        new Thread(w, "視窗2").start();
        new Thread(w, "視窗3").start();
    }
}

問題的原因：

• 當多條語句在操作同一個執行緒共享資料時，一個執行緒對多條語句只執行了一部分，還沒有 執行完，另一個執行緒參與進來執行。導致共享資料的錯誤。

解決辦法：

• 對多條操作共享資料的語句，只能讓一個執行緒都執行完，在執行過程中，其他執行緒不可以 參與執行。

在程式之中就可以通過兩種方式完成：一種是同步程式碼塊，另外一種就是同步方法。最後還有新增的Lock鎖

2. 同步程式碼塊

使用synchronized關鍵字定義的程式碼塊就稱為同步程式碼塊，但是在進行同步的操作之中必須設定一個要同步的物件，而這個物件應該理解為當前物件：this，必須保證唯一

//同步程式碼塊： 
synchronized (物件){ 
// 需要被同步的程式碼； 
}
//synchronized還可以放在方法宣告中，表示整個方法為同步方法。 
//例如： 
public synchronized void show (String name){
…. 
}

操作共享資料的程式碼，就是需要同步的程式碼

共享資料：多個執行緒共同操作的變數

使用同步程式碼塊解決實現Runnable介面的方式的執行緒安全問題

多個執行緒要公用一把鎖，這裡用的是this，因為是實現這個介面，後面就new了一個物件

/**
 * @author MD
 * @create 2020-07-11 9:25
 */

class Window implements Runnable{

    private int ticket = 100;
    @Override
    public void run() {
        while (true){

            synchronized (this){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }


                if (ticket > 0){
                    System.out.println(Thread.currentThread().getName() +"：賣票，票號為" + ticket);
                    ticket--;
                }else {
                    break;
                }
            }

        }
    }
}

public class WindowTest {

    public static void main(String[] args) {
        Window w = new Window();

        new Thread(w, "視窗1").start();
        new Thread(w, "視窗2").start();
        new Thread(w, "視窗3").start();
    }
}

同步的方式，解決了執行緒安全的問題

但是操作同步程式碼的時候，只能有一個程式參與，其他的程式等待，相當於一個單執行緒的過程，這個時候效率低

使用同步程式碼塊解決繼承Thread類的方式的執行緒安全問題

這裡的同步鎖不能再用this了，因為後面new了多個物件

注意宣告為靜態的

class Window2 extends Thread {
    // 這裡要注意宣告為靜態的
    private static int ticket = 100;
    private static Object obj = new Object();

    @Override
    public void run() {
        while (true) {
			// 也可以寫成這樣
            //  synchronized (Window2.class)
            synchronized (obj){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "：賣票，票號為" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

public class WindowTest2 {

    public static void main(String[] args) {
        Window2 w1 = new Window2();
        Window2 w2 = new Window2();
        Window2 w3 = new Window2();

        w1.setName("視窗1");
        w1.start();

        w2.setName("視窗2");
        w2.start();
        w3.setName("視窗3");
        w3.start();
    }
}

3. 同步方法

如果操作共享資料的程式碼完整的宣告在一個方法中，可以將這個方法宣告為同步的，這個方法就是同步方法

• 同步方法仍然涉及到同步監視器，只是不需要我們顯示的宣告
• 非靜態的方法，同步監視器就是this，靜態的方法同步監視器就是當前類本身

使用同步方法解決實現Runnable介面的執行緒問題

將方法宣告為同步就行使用synchronized

package com.atguigu.java;

/**
 * @author MD
 * @create 2020-07-11 10:32
 */

class Window3 implements Runnable {

    private int ticket = 100;

    @Override
    public void run() {
        while (true) {
            show();
        }
    }

    // 直接把這個方法宣告為這個就可以了 
    // 這個同步監視器就是this
    public synchronized void show(){
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        if (ticket > 0) {
            System.out.println(Thread.currentThread().getName() + "：賣票，票號為" + ticket);
            ticket--;
        }
    }
}

public class WindowTest3 {
    public static void main(String[] args) {
        Window3 w = new Window3();

        new Thread(w, "視窗1").start();
        new Thread(w, "視窗2").start();
        new Thread(w, "視窗3").start();
    }
}

使用同步方法解決繼承Thread的執行緒問題

將方法宣告為同步使用synchronized，並且該方法為靜態的使用static

package com.atguigu.java;

/**
 * @author MD
 * @create 2020-07-11 10:39
 */

class Window4 extends Thread {
    private static int ticket = 100;

    @Override
    public void run() {
        while (true) {
            show();
        }
    }

    // 此時的同步鎖是當前的類
    private static synchronized void show(){
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


        if (ticket > 0) {
            System.out.println(Thread.currentThread().getName() + "：賣票，票號為" + ticket);
            ticket--;
        }
    }
}

public class WindowTest4 {
    public static void main(String[] args) {
        Window4 w1 = new Window4();
        Window4 w2 = new Window4();
        Window4 w3 = new Window4();

        w1.setName("視窗1");
        w1.start();

        w2.setName("視窗2");
        w2.start();
        w3.setName("視窗3");
        w3.start();
    }
}

4. 死鎖

同步就是指一個執行緒要等待另外一個執行緒執行完畢才會繼續執行的一種操作形式，但是如果在一個操作之中都是在互相等著的話，那麼就會出現死鎖問題。

面試題：請問多個執行緒操作同一資源的時候要考慮到那些，會帶來那些問題？

多個執行緒訪問同一資源的時候一定要考慮到同步的問題，但是過多的同步會帶來死鎖。

package com.atguigu.java1;

/**
 * @author MD
 * @create 2020-07-11 11:01
 */
public class ThreadTest {
    public static void main(String[] args) {
        StringBuilder s1 = new StringBuilder();
        StringBuilder s2 = new StringBuilder();

        new Thread(){
            @Override
            public void run() {
                synchronized (s1){
                    s1.append("a");
                    s2.append("1");

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (s2){
                        s1.append("b");
                        s2.append("2");
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }.start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (s2) {
                    s1.append("c");
                    s2.append("3");

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (s1) {
                        s1.append("d");
                        s2.append("4");
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }).start();

    }
}

5. 解決執行緒安全問題的方式三：Lock鎖 ----JDK5.0 新增

• 例項化ReentrantLock
• 呼叫鎖定方法lock()
• 呼叫解鎖方法 unlock()

class A{
private final ReentrantLock lock = new ReenTrantLock(); 
    public void m(){ 
        lock.lock(); 
        try{ 
            //保證執行緒安全的程式碼; 
        } 
        finally{ 
            lock.unlock();  
        } 
    }
}
//注意：如果同步程式碼有異常，要將unlock()寫入finally語句塊

面試題：synchronized和Lock的異同

• Lock是顯式鎖（手動開啟和關閉鎖，別忘記關閉鎖），synchronized是 隱式鎖，出了作用域自動釋放
• Lock只有程式碼塊鎖，synchronized有程式碼塊鎖和方法鎖
• 使用Lock鎖，JVM將花費較少的時間來排程執行緒，效能更好。並且具有 更好的擴充套件性（提供更多的子類）
• 優先使用順序： Lock ------> 同步程式碼塊（已經進入了方法體，分配了相應資源）--->同步方法 （在方法體之外）

注意：如果是使用繼承Thread的方式，lock鎖得加一個static，這樣才能保證是同一把鎖

package com.atguigu.java1;

import java.util.concurrent.locks.ReentrantLock;

/**
 * @author MD
 * @create 2020-07-11 16:00
 */

class Window implements Runnable{

    private int ticket = 100;

    // 1. 例項化ReentrantLock
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true){
            try {
                // 2. 呼叫鎖定方法lock()
                lock.lock();
                if (ticket > 0){

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + " :售票，票號為：" + ticket);
                    ticket--;
                }else {
                    break;
                }
            }finally {
                //3. 呼叫解鎖方法 unlock()
                lock.unlock();
            }

        }
    }
}
public class LockTest {
    public static void main(String[] args) {
        Window w1 = new Window();
        new Thread(w1,"視窗1").start();
        new Thread(w1,"視窗2").start();
        new Thread(w1,"視窗3").start();

    }
}

如何解決執行緒安全問題？有幾種方式？

同步機制，三種方式

6. 練習

五、執行緒的通訊

使用兩個執行緒交替列印1-100

package com.atguigu.java2;

/**
 * @author MD
 * @create 2020-07-11 16:44
 */

class Number implements Runnable{

    private int number = 1;
    @Override
    public void run() {
        while (true){

            synchronized (this){

                notify();

                if (number <= 100){
                    System.out.println(Thread.currentThread().getName() + " : "+number);
                    number++;

                    // 使得呼叫wait()方法的執行緒進入到了阻塞狀態
                    try {
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else {
                    break;
                }
            }


        }

    }
}
public class CommunicationTest {
    public static void main(String[] args) {
        Number n = new Number();
        new Thread(n,"A").start();
        new Thread(n,"B").start();
    }
}

wait() 與 notify() 和 notifyAll()

• wait()：令當前執行緒掛起並放棄CPU、同步資源並等待，使別的執行緒可訪問並修改共享資源，而當 前執行緒排隊等候其他執行緒呼叫notify()或notifyAll()方法喚醒，喚醒後等待重新獲得對監視器的所有 權後才能繼續執行。
• notify()：喚醒正在排隊等待同步資源的執行緒中優先順序最高者結束等待
• notifyAll ()：喚醒正在排隊等待資源的所有執行緒結束等待.

注意

• 這三個方法只有在synchronized方法或synchronized程式碼塊中才能使用，否則會報 java.lang.IllegalMonitorStateException異常。
• 因為這三個方法必須有鎖物件呼叫，而任意物件都可以作為synchronized的同步鎖， 因此這三個方法在Object類中宣告

1. wait() 方法

• 在當前執行緒中呼叫方法： 物件名.wait()
• 使當前執行緒進入等待（某物件）狀態 ，直到另一執行緒對該物件發出 notify (或notifyAll) 為止。
• 呼叫方法的必要條件：當前執行緒必須具有對該物件的監控權（加鎖）
• 呼叫此方法後，當前執行緒將釋放物件監控權 ，也就是釋放當前的鎖，然後進入等待
• 在當前執行緒被notify後，要重新獲得監控權，然後從斷點處繼續程式碼的執行。

2. notify()/notifyAll()

• 在當前執行緒中呼叫方法： 物件名.notify()
• 功能：喚醒等待該物件監控權的一個/所有執行緒。
• 呼叫方法的必要條件：當前執行緒必須具有對該物件的監控權（加鎖）

3. 面試題：sleep()和wait()方法的異同

• 都可以使當前的程式進入到阻塞狀態
• 不同點
  • 兩個方法宣告的位置不同，sleep()是在Thread類中宣告的，wait()方法是在Object類中宣告的
  • 呼叫的範圍不同，sleep()可以在任何需要的場景下呼叫，wait()必須在同步程式碼塊或同步方法中呼叫
  • 關於是否釋放同步監視器：如果兩個方法都是使用在同步程式碼塊中，那麼sleep()方法不會釋放鎖，而wait()方法會釋放鎖

4. 生產者消費者問題

package com.atguigu.exer;

/**
 * @author MD
 * @create 2020-07-11 17:14
 */
class Clerk{

    private int productCount = 0;
    // 生產產品
    public synchronized void produceProduct() {
        if (productCount < 20){
            productCount++;
            System.out.println(Thread.currentThread().getName() + "：開始生產第 "+productCount+"個產品");

            notify();
        }else{
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    // 消費產品
    public synchronized void consumeProduct() {
        if (productCount > 0){
            System.out.println(Thread.currentThread().getName() +"：開始消費產品第" + productCount+"個產品");
            productCount--;

            notify();
        }else{
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}


// 生產者
class Producer extends Thread{
    private Clerk clerk;

    public Producer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {

        System.out.println(getName()+": 開始生成產品");

        while (true){
            
            clerk.produceProduct();
        }
    }
}

// 消費者
class Consumer extends Thread{
    private Clerk clerk;

    public Consumer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {

        System.out.println(getName()+": 開始消費產品");
        
        while (true){
            clerk.consumeProduct();
        }
    }
}


public class ProdectTest {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();

        Producer p1 = new Producer(clerk);
        p1.setName("生產者1");
        p1.start();
        Consumer c1 = new Consumer(clerk);
        c1.setName("消費者1");
        c1.start();

    }
}

六、新增執行緒建立方式

1. 實現Callable介面

與使用Runnable相比， Callable功能更強大些

• 相比run()方法，可以有返回值
• 方法可以丟擲異常 ，被外面的操作捕獲，獲取異常資訊
• 支援泛型的返回值
• 需要藉助FutureTask類，比如獲取返回結果

具體步驟如下：

package com.atguigu.java2;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * @author MD
 * @create 2020-07-11 17:43
 */

// 1. 建立一個實現Callable介面的實現類
class NumThread implements Callable{

    //2. 實現call()方法，將此執行緒需要執行的操作宣告在call()方法中
    @Override
    public Object call() throws Exception {

        int sum = 0;
        for (int i = 0; i <= 100; i++) {
            if (i % 2 == 0){
                sum += i;
            }
        }

        return sum;
    }
}

public class ThreadNew {
    public static void main(String[] args) {
        //3. 建立Callable介面實現類的物件
        NumThread numThread = new NumThread();

        // 4. 將Callable介面實現類的物件作為引數傳遞到FutureTask構造器中，建立FutureTask的物件
        FutureTask futureTask = new FutureTask(numThread);

        //5. 將FutureTask的物件作為引數傳遞到Threa類的構造器中，建立Thread物件，並呼叫start()方法
        new Thread(futureTask).start();

        //6. 如果需要返回值就寫下面的get()方法，
        try {
            // get()返回值就是FutureTask構造器引數Callable實現重寫call()的返回值
            Object sum = futureTask.get();
            System.out.println(sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

2. 使用執行緒池

背景：經常建立和銷燬、使用量特別大的資源，比如併發情況下的執行緒， 對效能影響很大。

思路：提前建立好多個執行緒，放入執行緒池中，使用時直接獲取，使用完 放回池中。可以避免頻繁建立銷燬、實現重複利用。類似生活中的公共交 通工具。

好處：

• 提高響應速度（減少了建立新執行緒的時間）
• 降低資源消耗（重複利用執行緒池中執行緒，不需要每次都建立）
• 便於執行緒管理 ：corePoolSize：核心池的大小 ，maximumPoolSize：最大執行緒數 ，keepAliveTime：執行緒沒有任務時最多保持多長時間後會終止

package com.atguigu.java2;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author MD
 * @create 2020-07-11 18:06
 */

class NumberThread implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if (i % 2 == 0){
                System.out.println(Thread.currentThread().getName()+ " : "+i );
            }

        }
    }
}

class NumberThread1 implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if (i % 2 != 0){
                System.out.println(Thread.currentThread().getName()+ " : "+i );
            }

        }
    }
}


public class ThreadTool {
    public static void main(String[] args) {
        // 1. 提供指定執行緒數量的執行緒池
        ExecutorService service = Executors.newFixedThreadPool(10);

        // 設定執行緒池的屬性
        


        //2. 執行指定的執行緒的操作，需要提供實現Runnable介面或實現Callable介面
        // 適合用於Runnable
        service.execute(new NumberThread());
        service.execute(new NumberThread1());

        // 適合用於Callable
        //service.submit();


        // 3. 最後關閉
        service.shutdown();
    }
}

七、面試題

1. Java是如何解決執行緒安全問題的，有幾種方式？有什麼不同？

2. synchronized和Lock的異同？

3. 寫一個執行緒安全的單例模式

4. sleep()和wait()方法的異同

5. 建立執行緒的方式(四種)？