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. 創建執行緒的方式(四種)？

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/142349.html

標籤：Java

上一篇：互聯網的寒冬下各大一線互聯網公司還在用SpringBoot這是為什么？

下一篇：資料源管理 | 搜索引擎框架，ElasticSearch集群模式