Java多線程詳解總結_ZenDei技術網路在線

一、基本概念程式(program): 是為完成特定任務、用某種語言編寫的一組指令的集合。即指一段靜態的代碼，靜態對象。進程(process):是程式的一次執行過程，或是正在運行的一個程式。是一個動態的過程：有它自身的產生、存在和消亡的過程。——生命周期運行中的QQ，運行中的MP3播放器程 ...

一、基本概念

程式(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();
    }
}

Java多線程詳解總結