多線程案例

1、案例一：線程安全的單例模式

單例模式

單例模式是設(shè)計(jì)模式的一種

什么是設(shè)計(jì)模式？
設(shè)計(jì)模式好比象棋中的 “棋譜”，紅方當(dāng)頭炮，黑方馬來跳，針對紅方的一些走法，黑方應(yīng)招的時候有一些固定的套路，按照套路來走局勢就不會吃虧，也就發(fā)明了一組"棋譜"，稱為設(shè)計(jì)模式

軟件開發(fā)中也有很多常見的 “問題場景”，針對一些典型的場景，給出了一些典型的解決方案

有兩個設(shè)計(jì)模式是非常常見的
其一是單例模式，其二是工廠模式

單例模式 => 單個 實(shí)例 (對象)

在有些場景中，有的特定的類，只能創(chuàng)建出一個實(shí)例，不應(yīng)該創(chuàng)建多個實(shí)例

單例模式能保證某個類在程序中只存在唯一一份實(shí)例, 而不會創(chuàng)建出多個實(shí)例，這種單例模式，在實(shí)際開發(fā)中是非常常見，也非常有用的，開發(fā)中的很多 “概念” 天然就是單例，JDBC，DataSource，這樣的對象，就應(yīng)該是單例的

Java 里實(shí)現(xiàn)單例模式的方式有很多，單例模式的兩種典型實(shí)現(xiàn)：

• 餓漢模式
• 懶漢模式

舉例：洗碗
1.中午這頓飯，使用了4個碗，吃完之后，立即把這4個碗給洗了~～[餓漢]
⒉中午這頓飯，使用了4個碗，吃完之后，先不洗。晚上這頓，只需要2個碗，然后就只洗2個即可~~[懶漢]

第二種是更加高效的操作，—般是褒義詞 (在計(jì)算機(jī)中提高效率)

餓漢的單例模式，是比較著急地去進(jìn)行創(chuàng)建實(shí)例
懶漢的單例模式，是不太著急地去創(chuàng)建實(shí)例，只是在用的時候，才真正創(chuàng)建

1.1、餓漢模式

private static Singleton instance;

注意：

1. 類里面使用 static 修飾的成員，應(yīng)該叫做 “類成員” => “類屬性 / 類方法”，相當(dāng)于這個屬性對應(yīng)的內(nèi)存空間在類對象里面
   不加 static 修飾的成員，叫做 “實(shí)例成員” => “實(shí)例屬性 / 實(shí)例方法”

   靜態(tài)變量 屬于類，存儲在方法區(qū)，隨著的類加載而加載，
   成員變量 屬于對象，存儲在堆中，隨著對象的創(chuàng)建而創(chuàng)建

   • static 是讓當(dāng)前 instance 屬性是類屬性了

   • 一個類對象在一個 Java 進(jìn)程中是唯一實(shí)例的 (JVM保證的)，類屬性是長在類對象上的，進(jìn)一步的也就保證了類的 static 成員也是只有一份的

2. 類對象 != 對象
   類：就相當(dāng)于實(shí)例的模板，基于模板可以創(chuàng)建出很多的對象來
   對象(實(shí)例)

   • java 代碼中的每個類，都會在編譯完成后得到 .class文件，類對象，就是 .class 文件
     JVM 運(yùn)行時就會加載這個 .class 文件讀取其中的二進(jìn)制指令，并解析，在內(nèi)存中構(gòu)造出對應(yīng)的類對象 (類加載)，形如 Singleton.class)
   • 類對象里就有 .class 文件中的一切信息
     包括：類名是啥，類里有哪些屬性，每個屬性叫啥名字，每個屬性叫啥類型，每個屬性是 public private…
     基于這些信息，才能實(shí)現(xiàn)反射

// 通過 Singleton 這個類來實(shí)現(xiàn)單例模式，保證 Singleton 這個類只有唯一實(shí)例
class Singleton {
    // 1．使用 static 創(chuàng)建一個實(shí)例,并且立即進(jìn)行實(shí)例化
    //   這個 instance 對應(yīng)的實(shí)例,就是該類的唯一實(shí)例
    private static Singleton instance = new Singleton();
  
    // 2．提供一個方法，讓外面能夠拿到唯一實(shí)例
    public static Singleton getInstance() {
        return instance;
    }
    
    // 3．為了防止程序猿在其他地方不小心地 new 這個 Singleton，就可以把構(gòu)造方法設(shè)為 private
    //   把構(gòu)造方法設(shè)為 private．在類外面，就無法通過 new的方式來創(chuàng)建這個 Singleton實(shí)例了!
    private Singleton() {};
}

public class demo1 {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2); // true 兩個引用相同
    }
}

針對這個唯一實(shí)例的初始化，比較著急，類加載階段，就會直接創(chuàng)建實(shí)例
(程序中用到了這個類，就會立即加載)

餓漢模式中 getlnstance，僅僅是讀取了變量的內(nèi)容
如果多個線程只是讀同一個變量，不修改，此時仍然是線程安全的

1.2、懶漢模式 - 單線程

class Singleton2 {
    // 1．就不是立即就初始化實(shí)例.
    private static Singleton2 instance = null;

    // 2．把構(gòu)造方法設(shè)為 private
    private Singleton2() {}

    // 3．提供一個方法來獲取到上述單例的實(shí)例
    //    只有當(dāng)真正需要用到這個實(shí)例的時候，才會真正去創(chuàng)建這個實(shí)例
    public static Singleton2 getInstance() {
        if (instance == null) {
            instance = new Singleton2();
        }
        return instance;
    }
}

只有在真正使用到 getInstance 的時候才會真的創(chuàng)建實(shí)例

一個典型的案例：
notepad 這樣的程序，在打開大文件的時候是很慢的 (你要打開一個1G大小的文件，此時 notepad 就會嘗試把這 1G 的所有內(nèi)容都讀到內(nèi)存中) [餓漢]
像一些其他的程序，在打開大文件的時候就有優(yōu)化 (要打開 1G 的文件，但是只先加載這—個屏幕中能顯示出來的部分) [懶漢]

1.3、懶漢模式 - 線程安全

真正要解決的問題，是實(shí)現(xiàn)一個線程安全的單例模式
線程安全不安全，具體指的是多線程環(huán)境下，并發(fā)的調(diào)用 getInstance 方法，是否可能存在 bug

——懶漢模式 與 餓漢模式 在多線程環(huán)境下，是否線程安全？

• 餓漢模式這里，多線程調(diào)用，只是涉及到"讀操作"

• 懶漢模式中，包含讀操作和修改操作，存在線程安全問題

上述羅列出了一種可能的排序情況，實(shí)際情況是有很多種
通過上述分析，就可以看出，當(dāng)前這個代碼中是存在bug，可能導(dǎo)致實(shí)例被創(chuàng)建出多份來

如何保證懶漢模式的線程安全呢？加鎖！

可不是說，代碼中有了 synchronized 就—定線程安全，synchronized 加的位置也得正確，不能隨便寫

本質(zhì)是讀，比較，寫，這三個操作不是原子的。這就導(dǎo)致了 t2 讀到的值可能是 t1 還沒來得及寫的(臟讀)，導(dǎo)致多次 new；所以要把鎖加在外面，此時才能保證 讀操作 和 修改操作 是一個整體

使用這里的類對象作為鎖對象
(類對象在一個程序中只有唯——份，就能保證多個線程調(diào)用 getInstance 的時候都是針對同一個對象進(jìn)行的加鎖)

public static Singleton2 getInstance() {
    synchronized (Singleton.class) { // 類對象作為鎖對象
        if (instance == null) {
            instance = new Singleton2();
        }
    }
    return instance;
}

1.4、懶漢模式 - 鎖競爭

當(dāng)前雖然加鎖之后，線程安全問題得到解決了，但是又有了新的問題：

對于剛才這個懶漢模式的代碼來說， 線程不安全，是發(fā)生在 instance 被初始化之前的，未初始化的時候，多線程調(diào)用 getinstance，就可能同時涉及到讀和修改，但是一旦 instance 被初始化之后，后續(xù)調(diào)用 getlnstance，此時 instance 的值一定是非空的，if 判斷不成立，也就線程安全了，因此就會直接觸發(fā) return，getlnstance 就只剩下兩個讀操作，相當(dāng)于一個是比較操作，一個是返回操作，這兩個都是讀操作

而按照上述的加鎖方式，無論代碼是初始化之后，還是初始化之前。加鎖是有開銷的，每次調(diào)用 getinstance 都會進(jìn)行加鎖，也就意味著即使是初始化之后 (已經(jīng)線程安全了)，但是仍然存在大量的鎖競爭 加鎖確實(shí)能讓代碼保證線程安全，也付出了代價 (程序的速度就慢了)

所以為啥不推薦使用 vector hashtable ?? 就是因?yàn)檫@倆類里面就是在無腦加鎖

改進(jìn)方案，在加鎖這里再加上一層條件判定即可，對象還沒創(chuàng)建，才進(jìn)行加鎖；對象創(chuàng)建過了，就不再加鎖了，
條件就是當(dāng)前是否已經(jīng)初始化完成 (instance == null)

class Singleton2 {
    // 1．就不是立即就初始化實(shí)例.
    private static Singleton2 instance = null;
    // 2．把構(gòu)造方法設(shè)為 private
    private Singleton2() {}
    // 3．提供一個方法來獲取到上述單例的實(shí)例
    //    只有當(dāng)真正需要用到這個實(shí)例的時候，才會真正去創(chuàng)建這個實(shí)例
    public static Singleton2 getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) { // 類對象作為鎖對象
                if (instance == null) {
                    instance = new Singleton2();
                }
            }
        }
        return instance;
    }
}

這倆條件—模一樣，只是一個美麗的巧合而已，這倆條件起到的效果 / 預(yù)期的目的是完全不—樣的
上面的條件判定的是是否要加鎖
下面的條件判定的是是否要創(chuàng)建實(shí)例
碰巧這兩個目的都是判定 instance 是否為 null

在這個代碼中，看起來兩個—樣的 if 條件是相鄰的，但是實(shí)際上這兩個條件的執(zhí)行時機(jī)是差別很大的！
加鎖可能導(dǎo)致線程阻塞，當(dāng)執(zhí)行到鎖結(jié)束之后，執(zhí)行到第二個 if 的時候，第二個 if 和第一個 if 之間可能已經(jīng)隔了很久的時間，滄海桑田。程序的運(yùn)行內(nèi)部的狀態(tài)，這些變量的值，都可能已經(jīng)發(fā)生很大改變了。 如外層條件是 10:16 執(zhí)行的，里層條件可能是 10:30 執(zhí)行的，此時 instance 可能已經(jīng)被其他線程給修改了。

如果去掉了里層的 if 就變成了剛才那個典型的錯誤代碼，加鎖沒有把讀＋修改這操作進(jìn)行打包

	public static Singleton2 getInstance() {
        if (instance == null) { // 判定的是是否要加鎖
            synchronized (Singleton.class) {
                instance = new Singleton2();
            }
        }
        return instance;
    }

1.5、懶漢模式 - 內(nèi)存可見性 指令重排序

當(dāng)前這個代碼中還存在一個重要的問題
如果多個線程，都去調(diào)用這里的 getlnstance
就會造成大量的讀 instance 內(nèi)存的操作 => 可能會讓編譯器把這個讀內(nèi)存操作優(yōu)化成讀寄存器操作
—旦這里觸發(fā)了優(yōu)化，后續(xù)如果第一個線程已經(jīng)完成了針對 instance 的修改，那么緊接著后面的線程都感知不到這個修改，仍然把 instance 當(dāng)成 null

另外，還會涉及到指令重排序問題!!

instance = new Singleton(); 拆分成三個步驟：

1.申請內(nèi)存空間
2.調(diào)用構(gòu)造方法，把這個內(nèi)存空間初始化成一個合理的對象
3.把內(nèi)存空間的地址賦值給 instance 引用

正常情況下，是按照 123 這個順序來執(zhí)行的
編譯器還有一手操作，指令重排序：為了提高程序效率，調(diào)整代碼執(zhí)行順序
123 這個順序就可能變成 132

如果是單線程，123 和 132 沒有本質(zhì)區(qū)別
例如食堂阿姨打飯，1 是拿盤子，2 是裝飯，3 是把盤子給我。此時，就是先把盤子給我，再裝飯

但是多線程環(huán)境下，就會有問題了!!!
假設(shè) t1 是按照 132 的步驟執(zhí)行的
t1 執(zhí)行到 13 之后，執(zhí)行 2 之前，被切出 cpu，t2 來執(zhí)行
(當(dāng) t1 執(zhí)行完 3 之后，t2 看起來，此處的引用就非空了)，此時此刻，t2 就相當(dāng)于直接返回了 instance 引用，并且可能會嘗試使用引用中的屬性
但是由于 t1 中的 2(裝飯) 操作還沒執(zhí)行完呢，t2 拿到的是非法的對象，還沒構(gòu)造完成的不完整的對象

解決方法：給 instance 加上 volatile 即可

// 這個代碼是完全體的線程安全單例模式
class Singleton2 {
    // 1．就不是立即就初始化實(shí)例.
    private static volatile Singleton2 instance = null;

    // 2．把構(gòu)造方法設(shè)為 private
    private Singleton2() {}

    // 3．提供一個方法來獲取到上述單例的實(shí)例
    //    只有當(dāng)真正需要用到這個實(shí)例的時候，才會真正去創(chuàng)建這個實(shí)例
    public static Singleton2 getInstance() {
        if (instance == null) { // 判定的是是否要加鎖
            synchronized (Singleton.class) { // 類對象作為鎖對象
                if (instance == null) { // 判定的是是否要創(chuàng)建實(shí)例
                    instance = new Singleton2();
                }
            }
        }
        return instance;
    }
}

2、案例二：阻塞隊(duì)列

2.1、生產(chǎn)者消費(fèi)者模型

隊(duì)列先進(jìn)先出
阻塞隊(duì)列同樣也是一個符合先進(jìn)先出規(guī)則的特殊隊(duì)列，相比于普通隊(duì)列，阻塞隊(duì)列又有一些其他方面的功能！
1、線程安全
2、產(chǎn)生阻塞效果

1). 如果隊(duì)列為空，執(zhí)行出隊(duì)列操作，就會出現(xiàn)阻塞，阻塞到另一個線程往隊(duì)列里添加元素（隊(duì)列不為空）為止
2). 如果隊(duì)列為滿，執(zhí)行入隊(duì)列操作，也會出現(xiàn)阻塞，阻塞到另一個線程從隊(duì)列里取走元素（隊(duì)列不為滿）為止

消息隊(duì)列，也是特殊的隊(duì)列，相當(dāng)于是在阻塞隊(duì)列的基礎(chǔ)上，加上了個 "消息的類型”，按照制定類別進(jìn)行先進(jìn)先出
此時咱們談到的這個消息隊(duì)列， 仍然是一個 “數(shù)據(jù)結(jié)構(gòu)”

基于上述特性，就可以實(shí)現(xiàn) “生產(chǎn)者消費(fèi)者模型”

此處的阻塞隊(duì)列就可以作為生產(chǎn)者消費(fèi)者模型中的交易場所

生產(chǎn)者消費(fèi)者模型，是實(shí)際開發(fā)中非常有用的一種多線程開發(fā)手段！尤其是在服務(wù)器開發(fā)的場景中
假設(shè)，有兩個服務(wù)器， AB，A作為入口服務(wù)器直接接收用戶的網(wǎng)絡(luò)請求，B作為應(yīng)用服務(wù)器，來給A提供一些數(shù)據(jù)

優(yōu)點(diǎn)1：解耦合

實(shí)現(xiàn)了發(fā)送發(fā)和接受方之間的解耦

——開發(fā)中典型的場景：服務(wù)器之間的相互調(diào)用

客戶端發(fā)送一個充值請求給 A 服務(wù)器，此時 A 把請求轉(zhuǎn)發(fā)給 B 處理，B 處理完了把結(jié)果反饋給 A，此時就可以視為是 “A 調(diào)用了 B”，

如果不使用生產(chǎn)者消費(fèi)者模型
上述場景中，A 和 B 之間的耦合性是比較高的! A 要調(diào)用 B，A 務(wù)必要知道 B的存在，如果 B 掛了，很容易引起 A 的 bug !!!（在開發(fā) A 代碼的時候就得充分了解到 B 提供的一些接口，開發(fā) B 代碼的時候也得充分了解到 A 是怎么調(diào)用的）

另外，如果要是再加一個 C 服務(wù)器，此時也需要對 A 修改不少代碼
因此就需要針對 A 重新修改代碼，重新測試，重新發(fā)布，重新部署，非常麻煩了

針對上述場景，使用生產(chǎn)者消費(fèi)者模型，就可以有效的降低耦合

對于請求：A是生產(chǎn)者，B是消費(fèi)者
對于響應(yīng)：A是消費(fèi)者，B是生產(chǎn)者
阻塞隊(duì)列都是作為交易場所，隊(duì)列是不變

A 不需要認(rèn)識 B，只需要關(guān)注如何和隊(duì)列交互 (A 的代碼中，沒有任何一行代碼和 B 相關(guān))
B 不需要認(rèn)識 A，也只需要關(guān)注如何和隊(duì)列交互 (B 的代碼中，也沒有任何一行代碼和 A 相關(guān))

如果 B 掛了，對于 A 沒有任何影響，因?yàn)殛?duì)列還好著，A 仍然可以給隊(duì)列插入元素，如果隊(duì)列滿，就先阻塞就好了，
如果 A 掛了，也對于 B 沒有影響，因?yàn)殛?duì)列還好著，B 仍然可以從隊(duì)列取元素，如果隊(duì)列空，也就先阻塞就好了
A B 任何一方掛了不會對對方造成影響!!!

新增一個 C 來作為消費(fèi)者，對于 A 來說，也完全感知不到…

優(yōu)點(diǎn)2：削峰填谷

能夠?qū)τ谡埱筮M(jìn)行 “削峰填谷”，保證系統(tǒng)的穩(wěn)定性

——三峽大壩，起到的效果，就是 “削峰填谷”

到了雨季，水流量就會很大，三峽大壩關(guān)閘蓄水，承擔(dān)了上游的沖擊，保護(hù)下游水流量不是太大，不至于出現(xiàn)洪災(zāi)——削峰
到了早季，水流量很小，三峽大壩就開閘放水，給下游提供更充分的水源，避免出現(xiàn)干旱災(zāi)害——填谷
什么時候上游漲水，真的是難以預(yù)測，防患于未然

上游，就是用戶發(fā)送的請求。下游就是一些執(zhí)行具體業(yè)務(wù)的服務(wù)器。
用戶發(fā)多少請求？不可控的，有的時候，請求多，有的時候請求少…

——未使用生產(chǎn)者消費(fèi)者模型：

未使用生產(chǎn)者消費(fèi)者模型的時候，如果請求量突然暴漲 (不可控)

A暴漲 => B暴漲
A 作為入口服務(wù)器，計(jì)算量很輕，請求暴漲，問題不大
B 作為應(yīng)用服務(wù)器，計(jì)算量可能很大，需要的系統(tǒng)資源也更多，如果請求更多了，需要的資源進(jìn)一步增加，如果主機(jī)的硬件不夠，可能程序就掛了

——使用生產(chǎn)者消費(fèi)者模型：

A 請求暴漲 => 阻塞隊(duì)列的請求暴漲

由于阻塞隊(duì)列沒啥計(jì)算量，就只是單純的存?zhèn)€數(shù)據(jù)，就能抗住更大的壓力
B 這邊仍然按照原來的速度來消費(fèi)數(shù)據(jù)，不會因?yàn)锳的暴漲而引起暴漲，B就被保護(hù)的很好，就不會因?yàn)檫@種請求的波動而引起崩潰

“削峰”：這種峰值很多時候不是持續(xù)的，就一陣，過去了就又恢復(fù)了
“填谷”：B 仍然是按照原有的頻率來處理之前積壓的數(shù)據(jù)

實(shí)際開發(fā)中使用到的 “阻塞隊(duì)列” 并不是一個簡單的數(shù)據(jù)結(jié)構(gòu)了，而是一個 / 一組專門的服務(wù)器程序，并且它提供的功能也不僅僅是阻塞隊(duì)列的功能，還會在這基礎(chǔ)之上提供更多的功能 (對于數(shù)據(jù)持久化存儲，支持多個數(shù)據(jù)通道，支持多節(jié)點(diǎn)容災(zāi)冗余備份，支持管理面板，方便配置參數(shù).……)
這樣的隊(duì)列又起了個新的名字，"消息隊(duì)列” (未來開發(fā)中廣泛使用到的組件)
kafka 就是業(yè)界一個比較主流的消息隊(duì)列，消息隊(duì)列的實(shí)現(xiàn),有很多種，核心功能都差不多

2.2、實(shí)現(xiàn)阻塞隊(duì)列

學(xué)會使用 Java 標(biāo)準(zhǔn)庫中的阻塞隊(duì)列，基于這個內(nèi)置的阻塞隊(duì)列，實(shí)現(xiàn)一個簡單的生產(chǎn)者消費(fèi)者模型
再自己**實(shí)現(xiàn)一個簡單的阻塞隊(duì)列 **(為了更好地理解阻塞隊(duì)列的原理，多線程，尤其是鎖操作)

標(biāo)準(zhǔn)庫中的阻塞隊(duì)列 BlockingQueue

在 Java 標(biāo)準(zhǔn)庫中內(nèi)置了阻塞隊(duì)列，如果我們需要在一些程序中使用阻塞隊(duì)列，直接使用標(biāo)準(zhǔn)庫中的即可

• BlockingQueue 是一個接口，真正實(shí)現(xiàn)的類是 LinkedBlockingQueue

• Queue 提供的方法有三個：入隊(duì)列 offer。出隊(duì)列 poll。取隊(duì)首元素 peek

  阻塞隊(duì)列主要方法是兩個：入隊(duì)列 put，出隊(duì)列 take

• BlockingQueue 也有 offer, poll, peek 等方法，但是這些方法不帶有阻塞特性

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class demo3 {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<String> blockingQueue = new LinkedBlockingQueue<>();
        blockingQueue.put("hello");
        String s1 = blockingQueue.take();
        System.out.println(s1);
        blockingQueue.take();
        String s2 = blockingQueue.take();
        System.out.println(s2);
    }
}

取出 “hello”，隊(duì)列為空，此時再次取元素，就會進(jìn)入阻塞，等待其他線程往隊(duì)列中添加元素

生產(chǎn)者消費(fèi)者模型

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;


public class ThreadDemo1 {
    public static void main(String[] args) {
        BlockingQueue<Integer> blockingQueue = new LinkedBlockingQueue<>();

        // 創(chuàng)建兩個線程，作為生產(chǎn)者和消費(fèi)者
        Thread customer = new Thread(() -> {
           while (true) {
               try {
                   Integer result = blockingQueue.take();
                   System.out.println("消費(fèi)元素：" + result);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
        });
        customer.start();

        Thread producer = new Thread(() -> {
            int count = 0;
            while (true) {
                try {
                    blockingQueue.put(count);
                    System.out.println("生產(chǎn)元素：" + count);
                    count++;
                    Thread.sleep(500); // 每500毫秒生產(chǎn)一個
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        producer.start();
    }
}

阻塞隊(duì)列 - 單線程

要實(shí)現(xiàn)一個阻塞隊(duì)列，需要先寫一個普通的隊(duì)列，再加上線程安全，再加上阻塞

隊(duì)列可以基于數(shù)組實(shí)現(xiàn)，也可以基于鏈表實(shí)現(xiàn)

——鏈表：很容易進(jìn)行頭刪 / 尾插
鏈表的頭刪操作，時間復(fù)雜度是 O(1)
鏈表的尾插操作，時間復(fù)雜度是 “可以是 O(1)"
用一個額外的引用，記錄當(dāng)前的尾結(jié)點(diǎn)

——數(shù)組：循環(huán)隊(duì)列

[head, tail) 都指向下標(biāo)為 0
入隊(duì)列，把新元素放到 tail 位置上，并且 tail++
出隊(duì)列，把 head 位置的元素返回出去，并且 head++
當(dāng) head / tail 到達(dá)數(shù)組末尾之后，就需要從頭開始，重新循環(huán)

實(shí)現(xiàn)循環(huán)隊(duì)列的時候，有一個重要的問題，如何區(qū)分，是空隊(duì)列還是滿隊(duì)列？
如果不加額外限制，此時隊(duì)列空或者滿都是 head 和 tail 重合

1. 浪費(fèi)一個格子，head == tail 認(rèn)為是空
   head == tail+1 認(rèn)為是滿

2. 額外創(chuàng)建一個變量，size 記錄元素的個數(shù)，size == 0 空
   size == arr.length 滿

class MyBlockingQueue {
    // 保存數(shù)據(jù)的本體
    private int[] items = new int[1000];
    // 隊(duì)首下標(biāo)
    private int head = 0;
    // 隊(duì)尾下標(biāo)
    private int tail = 0;
    // 有效元素個數(shù)
    private int size = 0;

    // 入隊(duì)列
    public void put(int value) {
        // 1、
        if (size == items.length) {
            // 隊(duì)列滿了，暫時先直接返回
            return;
        }
        // 2、把新的元素放入 tail 位置
        items[tail] = value;
        tail++;
        // 3、處理 tail 到達(dá)數(shù)組末尾的情況
        if (tail >= items.length) { // 判定 + 賦值 (雖然是兩個操作，兩個操作都是高效操作)
            tail = 0;
        }
        // tail = tail % data.length; // 代碼可讀性差，除法速度不如比較，不利于開發(fā)效率也不利于運(yùn)行效率
        // 4、插入完成，修改元素個數(shù)
        size++;
    }

    // 出隊(duì)列
    public Integer take() {
        // 1、
        if (size == 0) {
            // 如果隊(duì)列為空，返回一個非法值
            return null;
        }
        // 2、取出 head 位置的元素
        int ret = items[head];
        head++;
        // 3、head 到末尾 重新等于 0
        if (head >= items.length) {
            head = 0;
        }
        // 4、數(shù)組元素個數(shù)--
        size--;
        return ret;
    }
}

public class TestDemo {
    public static void main(String[] args) {
        MyBlockingQueue queue = new MyBlockingQueue();
        queue.put(1);
        queue.put(2);
        queue.put(3);
        queue.put(4);
        System.out.println(queue.take()); // 1
        System.out.println(queue.take()); // 2
        System.out.println(queue.take()); // 3
        System.out.println(queue.take()); // 4
    }
}

阻塞隊(duì)列 - 線程安全

當(dāng)前已經(jīng)完成了普通隊(duì)列的實(shí)現(xiàn)，加上阻塞功能，阻塞功能意味著，隊(duì)列要在多線程環(huán)境下使用 。保證多線程環(huán)境下，調(diào)用這里的 put 和 take 沒有問題的，

put 和 take 里面的每一行代碼都是在操作公共的變量。既然如此，直接就給整個方法加鎖即可
(加上 synchronized 已經(jīng)是線程安全的了)

// 入隊(duì)列
public void put(int value) {
    // 此處是把 synchronized 包裹了方法里的所有代碼，其實(shí) synchronized 加到方法上，也是一樣的效果
    synchronized (this) { // 針對同一個 MyBlockingQueue，進(jìn)行 put，take 操作時，會產(chǎn)生鎖競爭
        if (size == items.length) {
            return;
        }
        items[tail] = value;
        tail++;
        if (tail >= items.length) {
            tail = 0;
        }
        size++;
    }
}

// 出隊(duì)列
public Integer take() {
    int ret = 0;
    synchronized (this) {
        if (size == 0) {
            return null;
        }
        ret = items[head];
        head++;
        if (head >= items.length) {
            head = 0;
        }
        size--;
    }
    return ret;
}

阻塞隊(duì)列 - 阻塞

接下來，實(shí)現(xiàn)阻塞效果
關(guān)鍵要點(diǎn)，使用 wait 和 notify 機(jī)制
對于 put 來說，阻塞條件，就是隊(duì)列為滿，對于 take 來說，阻塞條件，就是隊(duì)列為空

針對哪個對象加鎖就使用哪個對象 wait， 如果是針對 this 加鎖，就 this.wait
put 中的 wait 要由 take 來喚醒，只要 take 成功了一個元素，就隊(duì)列不滿了，就可以進(jìn)行喚醒了
對于 take 中的等待，條件是隊(duì)列為空，隊(duì)列不為空，也就是 put 成功之后，就來喚醒

當(dāng)前代碼中，put 和 take 兩種操作不會同時 wait (等待條件是截然不同的，一個是為空，一個是為滿)

如果有人在等待，notify 能喚醒，如果沒人等待，notify 沒有任何副作用

notify 只能喚醒隨機(jī)的一個等待的線程，不能做到精準(zhǔn)
要想精準(zhǔn)，就必須使用不同的鎖對象
想喚醒 t1，就 o1.notify，讓 t1 進(jìn)行 o1.wait。想喚醒 t2，就 o2.notify，讓 t2 進(jìn)行 o2.wait

當(dāng) wait 被喚醒的時候，此時 if 的條件，一定就不成立了嘛?? 具體來說，put 中的 wait 被喚醒，要求，隊(duì)列不滿
但是 wait 被喚醒了之后，隊(duì)列一定是不滿的嘛？
注意，咱們當(dāng)前代碼中，確實(shí)不會出現(xiàn)這種情況，當(dāng)前代碼一定是取元素成功才喚醒，每次取元素都會喚醒
但是穩(wěn)妥起見，最好的辦法，是 wait 返回之后再次判定一下，看此時的條件是不是具備了!!

將 if 改為 while，標(biāo)準(zhǔn)庫就是建議這么寫的

while (size == items.length) {
    // 隊(duì)列滿了，暫時先直接返回
    // return;
    this.wait();
} 

while (size == 0) {
    // 如果隊(duì)列為空，返回一個非法值
    // return null;
    this.wait();
}

代碼：

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

// 自己寫的阻塞隊(duì)列，此處不考慮泛型，直接使用 int 來表示元素類型了
class MyBlockingQueue {
    // 保存數(shù)據(jù)的本體
    private int[] items = new int[1000];
    // 隊(duì)首下標(biāo)
    private int head = 0;
    // 隊(duì)尾下標(biāo)
    private int tail = 0;
    // 有效元素個數(shù)
    private int size = 0;

    // 入隊(duì)列
    public void put(int value) throws InterruptedException {
        synchronized (this) { // 針對同一個 MyBlockingQueue，進(jìn)行 put，take 操作時，會產(chǎn)生鎖競爭
            while (size == items.length) {
                // 隊(duì)列滿了，暫時先直接返回
                // return;
                this.wait();
            }
            // 2、把新的元素放入 tail 位置
            items[tail] = value;
            tail++;
            // 3、處理 tail 到達(dá)數(shù)組末尾的情況
            if (tail >= items.length) { // 判定 + 賦值 (雖然是兩個操作，兩個操作都是高效操作)
                tail = 0;
            }
            // tail = tail % data.length; // 代碼可讀性差，除法速度不如比較，不利于開發(fā)效率也不利于運(yùn)行效率
            // 4、插入完成，修改元素個數(shù)
            size++;

            // 如果入隊(duì)列成功，則隊(duì)列非空，喚醒 take 中的 wait
            this.notify();
        }
    }

    // 出隊(duì)列
    public Integer take() throws InterruptedException {
        int ret = 0;
        synchronized (this) {
            while (size == 0) {
                // 如果隊(duì)列為空，返回一個非法值
                // return null;
                this.wait();
            }
            // 2、取出 head 位置的元素
            ret = items[head];
            head++;
            // 3、head 到末尾 重新等于 0
            if (head >= items.length) {
                head = 0;
            }
            // 4、數(shù)組元素個數(shù)--
            size--;

            // take 成后，喚醒 put 中的 wait
            this.notify();
        }
        return ret;
    }
}

public class ThreadDemo2 {
    public static void main(String[] args) {
        // 生產(chǎn)者消費(fèi)者模型
        BlockingQueue<Integer> blockingQueue = new LinkedBlockingQueue<>();

        // 創(chuàng)建兩個線程，作為生產(chǎn)者和消費(fèi)者
        Thread customer = new Thread(() -> {
            while (true) {
                try {
                    Integer result = blockingQueue.take();
                    System.out.println("消費(fèi)元素：" + result);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        customer.start();

        Thread producer = new Thread(() -> {
            int count = 0;
            while (true) {
                try {
                    blockingQueue.put(count);
                    System.out.println("生產(chǎn)元素：" + count);
                    count++;
                    Thread.sleep(500); // 每500毫秒生產(chǎn)一個
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        producer.start();
    }
}

3、案例三：定時器

3.1、標(biāo)準(zhǔn)庫中的定時器 Timer

定時器也是軟件開發(fā)中的一個重要組件，類似于一個 “鬧鐘”，達(dá)到一個設(shè)定的時間之后，就喚醒并執(zhí)行之前設(shè)定好的任務(wù)

生活中鬧鐘，有兩種風(fēng)格：1.指定特定時刻，提醒。2.指定特定時間段之后，提醒
這里的定時器，不是提醒，是執(zhí)行一個實(shí)現(xiàn)準(zhǔn)備好的方法/代碼

定時器是一種實(shí)際開發(fā)中非常常用的組件

比如網(wǎng)絡(luò)通信中，很容易出現(xiàn) “連不上” 的情況，不能一直等，就可以使用定時器來進(jìn)行 “止損”，如果對方 500ms 內(nèi)沒有返回?cái)?shù)據(jù)，則斷開連接嘗試重連
比如一個 Map，希望里面的某個 key 在 3s 之后過期(自動刪除)

類似于這樣的場景就需要用到定時器

join (指定超時時間)，sleep (休眠指定時間，是基于系統(tǒng)內(nèi)部的定時器，來實(shí)現(xiàn)的)

先介紹標(biāo)準(zhǔn)庫的定時器用法，然后再看看如何自己實(shí)現(xiàn)一個定時器

標(biāo)準(zhǔn)庫中提供了一個 Timer 類，Timer 類的核心方法為 schedule (安排)，這個方法的效果是給定時器，注冊一個任務(wù)，任務(wù)不會立即執(zhí)行，而是在指定時間進(jìn)行執(zhí)行
schedule 包含兩個參數(shù)，第一個參數(shù)指定即將要執(zhí)行的任務(wù)代碼 (Runnable)，第二個參數(shù)指定多長時間之后執(zhí)行 (單位為毫秒)

import java.util.Timer;
import java.util.TimerTask;

public class demo5 {
    public static void main(String[] args) {
        Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("hello time");
            }
        }, 3000);
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("hello time2");
            }
        }, 2000);
        System.out.println("main");
    }
}

運(yùn)行結(jié)果：
首先打?。簃ain
幾秒后 打印：hello time2
然后打?。篽ello time
但是程序沒有結(jié)束

Timer 內(nèi)部是有專門的線程，來負(fù)責(zé)執(zhí)行注冊的任務(wù)的

Timer 內(nèi)部都需要：

1. 管理很多的任務(wù)
2. 執(zhí)行時間到了的任務(wù)

自己實(shí)現(xiàn)一個定時器：一個定時器是可以注冊 N 個任務(wù)的，N 個任務(wù)會按照最初約定的時間，按順序執(zhí)行

1). 有一個掃描線程，負(fù)責(zé)判定時間到/執(zhí)行任務(wù) (單獨(dú)在定時器內(nèi)部，搞個線程，讓這個線程周期性地掃描，判定任務(wù)是否是到時間了，如果到時間了，就執(zhí)行，沒到時間就再等等)

2). 還要有一個數(shù)據(jù)結(jié)構(gòu)(優(yōu)先級隊(duì)列)，來保存所有被注冊的任務(wù)

3.2、描述任務(wù)

創(chuàng)建一個專門的類來表示一個定時器中的任務(wù) (TimerTask)

隊(duì)列中存放的任務(wù)就是 Runnable，Runnable 只是描述了任務(wù)內(nèi)容，還需要描述任務(wù)什么時候被執(zhí)行

// 創(chuàng)建一個類，表示一個任務(wù)
class MyTask {
    // 任務(wù)具體要做什么
    private Runnable runnable;
    // 任務(wù)什么時候執(zhí)行 (任務(wù)要執(zhí)行的毫秒級時間戳)
    private long time;

    public MyTask(Runnable runnable, long time) {
        this.runnable = runnable;
        this.time = time;
    }
    
    // 獲取當(dāng)前任務(wù)時間
    public long getTime() {
        return time;
    }

    // 執(zhí)行任務(wù)
    public void run() {
        runnable.run();
    }
}

3.2、組織任務(wù)

使用一定的數(shù)據(jù)結(jié)構(gòu)把一些任務(wù)給放到一起，通過一定的數(shù)據(jù)結(jié)構(gòu)來組織

假設(shè)現(xiàn)在有多個任務(wù)過來了—個小時之后，去做作業(yè)，三個小時之后，去上課，10分鐘之后，去休息—會
安排任務(wù)的時候，這些任務(wù)的順序是無序的，但是執(zhí)行任務(wù)的時候，這就不是無序的了，按照時間先后來執(zhí)行！
咱們的需求就是，能夠快速找到所有任務(wù)中，時間最小的任務(wù)

此時我們發(fā)現(xiàn)可以用堆，在標(biāo)準(zhǔn)庫中，有一個專門的數(shù)據(jù)結(jié)構(gòu) PriorityQueue

咱們這里的每個任務(wù)都是帶個"時間"多久之后執(zhí)行，一定是時間越靠前，就先執(zhí)行
按照時間小的，作為優(yōu)先級高
此時隊(duì)首元素，就是整個隊(duì)列中，最先要執(zhí)行的任務(wù)
雖然隊(duì)列中的元素順序，不能完全確定，但是可以知道，隊(duì)首元素，一定是時間最靠前的
此時，掃描線程，只需要掃一下隊(duì)首元素即可，不必遍歷整個隊(duì)列

private PriorityQueue<> queue = new PriorityQueue<>();

但是此處的優(yōu)先級隊(duì)列要在多線程環(huán)境下使用，要考慮到線程安全問題，可能在多個線程里進(jìn)行注冊任務(wù)，同時還有一個專門的線程來取任務(wù)執(zhí)行，此處的隊(duì)列就需要注意線程安全問題
所以我們得使用 PriorityBlockingQueue ，既帶有優(yōu)先級又帶有阻塞隊(duì)列

private PriorityBlockingQueue<> queue = new PriorityBlockingQueue<>();

// 自己寫個簡單的定時器
class MyTimer {
    // 掃描線程
    private Thread t = null;

    // 定時器內(nèi)部要能夠存放多個任務(wù) 阻塞優(yōu)先級隊(duì)列保存任務(wù)
    private PriorityBlockingQueue<MyTask> queue = new PriorityBlockingQueue<>();

    public MyTimer() {
        // TODO
    }
    
    /** 定時器提供一個 schedule 方法，注冊任務(wù)
     * @param runnable 要執(zhí)行的任務(wù)
     * @param after 多長時間(毫秒)之后執(zhí)行
     */
    public void schedule(Runnable runnable, long after) {
        MyTask task = new MyTask(runnable, System.currentTimeMillis() + after);
        queue.put(task); // 任務(wù)放入堆
    }
}

——執(zhí)行時間到了的任務(wù)：

需要先執(zhí)行時間最考前的任務(wù)
就需要有一個掃描線程，不停地去檢查當(dāng)前優(yōu)先隊(duì)列的隊(duì)首元素，看看當(dāng)前最靠前的這個任務(wù)是不是時間到了

在定時器構(gòu)造方法中 創(chuàng)建線程進(jìn)行掃描

阻塞隊(duì)列，只能先把元素出隊(duì)列才好判定，不滿足還得放回去
這不像普通隊(duì)列，可以直接取隊(duì)首元素判定的

public MyTimer() {
    t = new Thread(() -> {
        while (true) {
            try {
                // 取出隊(duì)首元素，再比較這個任務(wù)有沒有到時間
                MyTask myTask = queue.take();
                long curTime = System.currentTimeMillis();
                if (curTime < (myTask).getTime()) { // 1.沒到時間，任務(wù)放回堆
                    queue.put(myTask);
                } else { // 2.時間到了，執(zhí)行任務(wù)
                    myTask.run();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    });
    t.start();
}

3.3、兩個缺陷

上述代碼中存在兩個非常嚴(yán)重的問題：

第—個缺陷： MyTask 沒有指定比較規(guī)則

像剛才咱們實(shí)現(xiàn)的 MyTask 這個類的比較規(guī)則，并不是默認(rèn)就存在的，這個需要咱們手動指定，按照時間大小來比較的
標(biāo)準(zhǔn)庫中的集合類，很多都是有一定的約束限制的，不是隨便拿個類都能放到這些集合類里面去的

——測試：

public class ThreadDemo {
    public static void main(String[] args) {
        MyTimer myTimer = new MyTimer();
        myTimer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("任務(wù)1");
            }
        }, 1000);
        myTimer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("任務(wù)2");
            }
        }, 2000);
    }
}

讓 MyTask 類實(shí)現(xiàn) Comparable接口，另外也可以使用 Comparator單獨(dú)寫個比較器

修改：

class MyTask implements Comparable<MyTask> {        
    @Override
    public int compareTo(MyTask o) {
        return (int) (this.time - o.time);
    }
}

第二個缺陷： 如果不加任何限制，這個循環(huán)就會執(zhí)行的非?？?/font>

import java.util.concurrent.PriorityBlockingQueue;

// 創(chuàng)建一個類，表示一個任務(wù)
class MyTask implements Comparable<MyTask> {
    // 任務(wù)具體要做什么
    private Runnable runnable;
    // 任務(wù)什么時候執(zhí)行 (任務(wù)要執(zhí)行的毫秒級時間戳)
    private long time;

    public MyTask(Runnable runnable, long time) {
        this.runnable = runnable;
        this.time = time;
    }

    // 獲取當(dāng)前任務(wù)時間
    public long getTime() {
        return time;
    }

    // 執(zhí)行任務(wù)
    public void run() {
        runnable.run();
    }

    @Override
    public int compareTo(MyTask o) {
        return (int) (this.time - o.time);
    }
}

// 自己寫個簡單的定時器
class MyTimer {
    // 掃描線程
    private Thread t = null;

    // 定時器內(nèi)部要能夠存放多個任務(wù) 阻塞優(yōu)先級隊(duì)列保存任務(wù)
    private PriorityBlockingQueue<MyTask> queue = new PriorityBlockingQueue<>();

    // 掃描線程
    public MyTimer() {
        t = new Thread(() -> {
            while (true) {
                try {
                    synchronized (this) {
                        // 取出隊(duì)首元素，再比較這個任務(wù)有沒有到時間
                        MyTask myTask = queue.take();
                        long curTime = System.currentTimeMillis();
                        if (curTime < (myTask).getTime()) { // 1.沒到時間，任務(wù)放回堆
                            queue.put(myTask);
                            // 在 put 后 wait
                            this.wait(myTask.getTime() - curTime);
                        } else { // 2.時間到了，執(zhí)行任務(wù)
                            myTask.run();
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
    }

    /** 定時器提供一個 schedule 方法，注冊任務(wù)
     * @param runnable 要執(zhí)行的任務(wù)
     * @param after 多長時間(毫秒)之后執(zhí)行
     */
    public void schedule(Runnable runnable, long after) {
        // 注意換算，time 是一個時間戳，不是絕對的時間戳的值
        MyTask task = new MyTask(runnable, System.currentTimeMillis() + after);
        queue.put(task); // 任務(wù)放入堆
        // 有新任務(wù)加入 notify
        synchronized (this) {
            this.notify();
        }
    }
}

public class ThreadDemo {
    public static void main(String[] args) {
        MyTimer myTimer = new MyTimer();
        myTimer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("任務(wù)1");
            }
        }, 1000);
        myTimer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("任務(wù)2");
            }
        }, 2000);
    }
}

任務(wù)1
任務(wù)2

ThreadPoolExecutor(int corePoolSize,
                   int maximumPoolSize, 
                   long keepAliveTime, 
                   TimeUnit unit, 
                   BlockingQueue<Runnable> workQueue, 
                   ThreadFactory threadFactory, 
                   RejectedExecutionHandler handler)
    Creates a new ThreadPoolExecutor with the given initial parameters.
    // 創(chuàng)建一個新 ThreadPoolExecutor 給定的初始參數(shù)

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

public class demo6 {
    public static void main(String[] args) {
        // 創(chuàng)建一個固定的線程數(shù)目的線程池，參數(shù)指定了線程的個數(shù)
        ExecutorService pool = Executors.newFixedThreadPool(10);
        // 創(chuàng)建一個自動擴(kuò)擴(kuò)容的線程池，線程數(shù)量動態(tài)變化，會根據(jù)任務(wù)量自動擴(kuò)容
        Executors.newCachedThreadPool();
        // 創(chuàng)建一個只有一個線程的線程池
        Executors.newSingleThreadExecutor();
        // 創(chuàng)建一個帶有定時器功能的線程池，類似于 Timer，只不過執(zhí)行的時候不是由掃描線程自己執(zhí)行，而是由單獨(dú)的線程池來執(zhí)行
        Executors.newScheduledThreadPool(10);
    }
}

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

public class demo6 {
    public static void main(String[] args) {
        ExecutorService pool = Executors.newFixedThreadPool(10);
        pool.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello threadPool!");
            }
        });
    }
}

hello threadPool!

public class ThreadDemo2 {
    public static void main(String[] args) {
        ExecutorService pool = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 1000; i++) {
            int n = i;
            pool.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println("hello pool! " + n);
                }
            });
        }
    }
}

class Point {
    // 使用笛卡爾坐標(biāo)系提供的坐標(biāo),來構(gòu)造點(diǎn)
    public Point(double x, double y) {}
	
    // 使用極坐標(biāo),來構(gòu)造點(diǎn)
    public Point(double r, double a) {}
}

class PointFactory {
    public static Point makePointByXY(double x, double y) {}

    public static Point makePointByRA(double r, double a) {}
}

Point p = PointFactory.makePointByXY(10,20);

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

// 實(shí)現(xiàn)一個固定線程數(shù)的線程池
class MyThreadPool {
    // 1、描述一個任務(wù)，不像定時器涉及"時間"，直接用 Runnable，不需要額外類
    // 2、使用一個數(shù)據(jù)結(jié)構(gòu)(阻塞隊(duì)列)來組織若干個任務(wù)
    private BlockingQueue<Runnable> queue = new LinkedBlockingQueue<>();

    // 在構(gòu)造方法中，創(chuàng)建若干個線程 (n 表示線程的數(shù)量)
    public MyThreadPool(int n) {
        // 在這里創(chuàng)建線程
        for (int i = 0; i < n; i++) {
            Thread t = new Thread(() -> {
                while (true) { // 從隊(duì)列中循環(huán)地取任務(wù)
                    try {
                        // 循環(huán)地獲取任務(wù)隊(duì)列中的任務(wù)，然后執(zhí)行
                        // 隊(duì)列為空，直接阻塞。隊(duì)列非空，就獲取內(nèi)容
                        Runnable runnable = queue.take(); // 獲取任務(wù)
                        runnable.run(); // 執(zhí)行任務(wù)
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
            t.start();
        }
    }

    // 創(chuàng)建一個方法，能夠允許程序員放任務(wù)到線程池中
    // 注冊任務(wù)給線程池，由這 10 個線程執(zhí)行
    public void submit(Runnable runnable) {
        try {
            queue.put(runnable);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class TestDemo {
    public static void main(String[] args) {
        MyThreadPool pool = new MyThreadPool(10);
        for (int i = 0; i < 1000; i++) {
            int n  = i;
            pool.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println("hello " + n);
                }
            });
        }
    }
}