一 .volatile關(guān)鍵字

?volatile是java提供的輕量級(jí)的同步機(jī)制揭璃，主要有三個(gè)特性：保證可見性披蕉，禁止指令重排榛臼，不保證原子性峻厚。

JMM（Java 內(nèi)存模型）

基本概念

?JMM本身是一種抽象的概念 并不真實(shí)存在霞玄，他描述的是一組定義或規(guī)范骤铃，通過這組規(guī)范規(guī)定了程序中的訪問方式
?JMM同步規(guī)定：
??1.線程解鎖前必須把共享變量的值刷回主內(nèi)存
??2.線程加鎖前把主內(nèi)存的值復(fù)制到自己的內(nèi)存
??3.加鎖和解鎖必須是同一把鎖拉岁。
?由于 JVM 運(yùn)行程序的實(shí)體是線程，而每個(gè)線程創(chuàng)建時(shí) JVM 都會(huì)為其創(chuàng)建一個(gè)工作內(nèi)存惰爬，工作內(nèi)存是每個(gè)線程的私有數(shù)據(jù)區(qū)域喊暖，而 Java 內(nèi)存模型中規(guī)定所有變量的儲(chǔ)存在主內(nèi)存，主內(nèi)存是共享內(nèi)存區(qū)域撕瞧，所有的線程都可以訪問陵叽，但線程對(duì)變量的操作（讀取賦值等）必須都工作內(nèi)存進(jìn)行看。
?首先要將變量從主內(nèi)存拷貝的自己的工作內(nèi)存空間丛版，然后對(duì)變量進(jìn)行操作巩掺，操作完成后再將變量寫回主內(nèi)存，不能直接操作主內(nèi)存中的變量硼婿，工作內(nèi)存中存儲(chǔ)著主內(nèi)存中的變量副本拷貝锌半，前面說過，工作內(nèi)存是每個(gè)線程的私有數(shù)據(jù)區(qū)域寇漫，因此不同的線程間無法訪問對(duì)方的工作內(nèi)存刊殉，線程間的通信(傳值)必須通過主內(nèi)存來完成。

1.可見性代碼示例

public class VolatileDemo {
    static int v1;

    public static void main(String[] args) {
        new Thread(new Runnable() {

            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                v1 = 100;

            }
        }).start();
        
        while (v1 == 0) {

        }
        System.out.println("v1 = " + v1);

    }

}

?上面示例無法輸出結(jié)果州胳，當(dāng)主線程已經(jīng)讀到v1的值時(shí)记焊，如果不加volatile關(guān)鍵字，另一個(gè)線程更改這個(gè)值不會(huì)去通知主線程栓撞。所以進(jìn)入死循環(huán)遍膜。如果加上volatile關(guān)鍵字，則會(huì)刷新主線程的v1的值瓤湘，打印之后結(jié)束主線程瓢颅。

2.不保證原子性代碼示例

public class VolatileDemo {
     static volatile int v1;
     public static void add(){
         v1++;
     }

    public static void main(String[] args) throws InterruptedException {

        for(int i = 0;i< 20;i++) {
            new Thread(new Runnable() {

                @Override
                public void run() {
                    for(int i = 0;i < 1000; i++){
                    add();
                    }
                }
            }).start();
        }
          //當(dāng)活動(dòng)線程只有主線程和GC時(shí)才進(jìn)行打印否則讓位其他線程
       while (Thread.activeCount() > 2){
           Thread.yield();
       }
        System.out.println("v1 = " + v1);

    }

}

?i++并非原子操作，包含三個(gè)步驟：1·讀取i的值 ? 2·將i的值加一?3·將加一后的值寫回i
?發(fā)現(xiàn)上面示例打印的總是比20000小弛说，說明volatile并不能保證原子性

3.禁止指令重排

?指令重排：一般情況下挽懦，CPU和編譯器為了提升程序執(zhí)行的效率，會(huì)按照一定的規(guī)則允許進(jìn)行指令優(yōu)化木人，在某些情況下信柿，這種優(yōu)化會(huì)帶來一些執(zhí)行的邏輯問題，主要的原因是代碼邏輯之間是存在一定的先后順序醒第，在并發(fā)執(zhí)行情況下渔嚷，會(huì)發(fā)生二義性，即按照不同的執(zhí)行邏輯稠曼，會(huì)得到不同的結(jié)果信息形病。
?volatile 實(shí)現(xiàn)禁止指令重排序的優(yōu)化，從而避免了多線程環(huán)境下程序出現(xiàn)亂序的現(xiàn)象
?先了解一個(gè)概念，內(nèi)存屏障（Memory Barrier）又稱內(nèi)存柵欄窒朋，是一個(gè) CPU 指令搀罢，他的作用有兩個(gè)：
??1.保證特定操作的執(zhí)行順序
??2.保證某些變量的內(nèi)存可見性（利用該特性實(shí)現(xiàn) volatile 的內(nèi)存可見性）
?由于編譯器個(gè)處理器都能執(zhí)行指令重排序優(yōu)化，如果在指令間插入一條 Memory Barrier 則會(huì)告訴編譯器和 CPU侥猩，不管什么指令都不能個(gè)這條 Memory Barrier 指令重排序榔至，也就是說通過插入內(nèi)存屏障禁止在內(nèi)存屏障前后執(zhí)行重排序優(yōu)化。內(nèi)存屏障另一個(gè)作用是強(qiáng)制刷出各種 CPU 緩存數(shù)據(jù)欺劳，因此任何 CPU 上的線程都能讀取到這些數(shù)據(jù)的最新版本唧取。

volatile常見用法（雙端檢鎖單例）

public class Singleton {
    private static volatile Singleton singleton;

    private Singleton() {
    }

    public static Singleton getInstance(){
        if(singleton == null){
            synchronized (Singleton.class){
                if(singleton == null){
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

?如果不加volatile多線程環(huán)境下存在指令重排的風(fēng)險(xiǎn)，singleton = new Singleton(); 可以分解為三條指令
??1.分配內(nèi)存地址
?? 2.初始化對(duì)象
?? 3.將內(nèi)存地址指向初始化對(duì)象
由于指令重排只保證單線程下程序的執(zhí)行結(jié)果划提，編譯可以優(yōu)化為132的順序枫弟，這樣在getInstance方法調(diào)用時(shí)singleton == null。加上volatile可以避免這個(gè)問題鹏往。

二.CAS （CompareAndSwap）比較并交換

?CAS是一種無鎖編程淡诗，對(duì)比synchronized效率更高。CAS操作包含三個(gè)操作數(shù)——內(nèi)存位置（V）伊履，預(yù)期原值（A）和新值（B）韩容。如果內(nèi)存位置的值與預(yù)期原值相匹配，那么處理器將會(huì)自動(dòng)將該位置值更新為新值唐瀑，否則群凶，不做任何操作。無論哪種情況哄辣，它都會(huì)在CAS指令之前返回該位置的值请梢。
通過以上定義我們知道CAS其實(shí)是有三個(gè)步驟的
??1.讀取內(nèi)存中的值
??2.將讀取的值和預(yù)期的值比較
??3.如果比較的結(jié)果符合預(yù)期，則寫入新值
?CAS 體現(xiàn)在 JAVA 語言中就是 sun.misc.Unsafe 類中的各個(gè)方法力穗。調(diào)用 UnSafe 類中的 CAS 方法毅弧，JVM 會(huì)幫我們實(shí)現(xiàn)出 CAS 匯編指令。這是一種完全依賴硬件的功能当窗，通過它實(shí)現(xiàn)了原子操作形真。由于 CAS 是一種系統(tǒng)源語，源語屬于操作系統(tǒng)用語范疇超全，是由若干條指令組成，用于完成某一個(gè)功能的過程邓馒，并且原語的執(zhí)行必須是連續(xù)的嘶朱，在執(zhí)行的過程中不允許被中斷，也就是說 CAS 是一條原子指令光酣，不會(huì)造成所謂的數(shù)據(jù)不一致的問題疏遏。

UnSafe類

public class AtomicInteger extends Number implements java.io.Serializable {
    private static final long serialVersionUID = 6214790243416807050L;

    // setup to use Unsafe.compareAndSwapInt for updates
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;

    static {
        try {
            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }

    private volatile int value;

    /**
     * Creates a new AtomicInteger with the given initial value.
     *
     * @param initialValue the initial value
     */
    public AtomicInteger(int initialValue) {
        value = initialValue;
    }

    /**
     * Creates a new AtomicInteger with initial value {@code 0}.
     */
    public AtomicInteger() {
    }

?Unsafe 是 CAS 的核心類，由于 Java 方法無法直接訪問底層系統(tǒng)，而需要通過本地（native）方法來訪問财异， Unsafe 類相當(dāng)一個(gè)后門倘零，基于該類可以直接操作特定內(nèi)存的數(shù)據(jù)。Unsafe 類存在于 sun.misc 包中戳寸，其內(nèi)部方法操作可以像 C 指針一樣直接操作內(nèi)存呈驶，因?yàn)?Java 中 CAS 操作執(zhí)行依賴于 Unsafe 類。
?變量 vauleOffset疫鹊，表示該變量值在內(nèi)存中的偏移量袖瞻，因?yàn)?Unsafe 就是根據(jù)內(nèi)存偏移量來獲取數(shù)據(jù)的。
?變量 value 用 volatile 修飾拆吆，保證了多線程之間的內(nèi)存可見性聋迎。

AtomicInteger示例代碼

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicDemo {

    public static void main(String[] args) {

        AtomicInteger i = new AtomicInteger(2019);
        System.out.println(i.compareAndSet(2019, 2020));  //true
        System.out.println(i); //2020
        
        AtomicInteger n = new AtomicInteger();
        System.out.println(n.compareAndSet(2019, 2020)); //false
        System.out.println(n); // 0
    }
}

除了JAVA提供的基本類型外還提供了AtuomicRefence 原子引用類，可以處理對(duì)象的原子類枣耀。

AtomicRefence示例代碼

import java.util.Objects;
import java.util.concurrent.atomic.AtomicReference;

public class AtomicDemo {

    public static void main(String[] args) {
        User user = new User("zhangsan", 18);
        AtomicReference atomicReference = new AtomicReference(user);
        atomicReference.compareAndSet(user,new User("lisi",20));
        System.out.println(atomicReference.get());
    }
}


class User {
    private String name;
    private int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

}

CAS的缺點(diǎn)

?1.循環(huán)時(shí)間長開銷很大霉晕。如果 CAS 失敗，會(huì)一直嘗試捞奕，如果 CAS 長時(shí)間一直不成功牺堰，可能會(huì)給 CPU 帶來很大的開銷（比如線程數(shù)很多，每次比較都是失敗缝彬，就會(huì)一直循環(huán)）萌焰，所以希望是線程數(shù)比較小的場景。
?2.只能對(duì)一個(gè)共享變量進(jìn)行原子操作谷浅，多個(gè)變量的情況不可用扒俯。
?3.會(huì)出現(xiàn)ABA問題

ABA問題

?兩個(gè)線程修改共享變量，共享變量由A改為B一疯，又由B改為A撼玄。此時(shí)另一個(gè)線程并不知道情況，以為共享變量的值沒有改變墩邀，將共享變量的值修改掌猛。

代碼示例

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicABADemo {

    public static void main(String[] args) {
        AtomicInteger i = new AtomicInteger();
        new Thread(new Runnable() {
            @Override
            public void run() {
                i.compareAndSet(0,1);
                System.out.println("i的值由0改為1");
                i.compareAndSet(1,0);
                System.out.println("i的值由1改為0");
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                i.compareAndSet(0,2019);
                System.out.println("ABA問題出現(xiàn)——》i的值由0改為2019");
            }
        }).start();
    }
}

解決方案
?java提供了一個(gè)帶有版本號(hào)的原子引用類AtomicStampedRefence，實(shí)際上就是一個(gè)樂觀鎖眉睹。

代碼示例

import java.util.concurrent.atomic.AtomicStampedReference;

public class AtomicDemo {
    public static void main(String[] args) {
        User user  = new User("zhangsan",18);
        // 傳入初始對(duì)象和版本號(hào)
        AtomicStampedReference atomicStampedReference = new AtomicStampedReference(user,0);
        User user1  = new User("lisi",20);

        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                atomicStampedReference.compareAndSet(user,user1,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
                System.out.println("版本號(hào)為" + atomicStampedReference.getStamp() + "荔茬，User對(duì)象信息為" + atomicStampedReference.getReference());
                atomicStampedReference.compareAndSet(user1,user,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
                System.out.println("版本號(hào)為" + atomicStampedReference.getStamp() + "，User對(duì)象信息為" + atomicStampedReference.getReference());

            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                int stamp = atomicStampedReference.getStamp();
                User user2  = new User("wangwu",28);
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                atomicStampedReference.compareAndSet(user,user2,stamp,stamp++);
                System.out.println("版本號(hào)為" + atomicStampedReference.getStamp() + "竹海，User對(duì)象信息為" + atomicStampedReference.getReference());


            }
        }).start();

    }
}


class User {
    private String name;
    private int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

}

三 .Java中的鎖

1.公平鎖與非公平鎖

?公平鎖：是指多個(gè)線程按照申請(qǐng)的順序來獲取值
?非公平鎖：是值多個(gè)線程獲取值的順序并不是按照申請(qǐng)鎖的順序慕蔚，有可能后申請(qǐng)的線程比先申請(qǐng)的線程優(yōu)先獲取鎖新啼，在高并發(fā)的情況下韩脑，可能會(huì)造成優(yōu)先級(jí)翻轉(zhuǎn)或者饑餓現(xiàn)象
兩者區(qū)別
?公平鎖：在并發(fā)環(huán)境中润绎，每一個(gè)線程在獲取鎖時(shí)會(huì)先查看此鎖維護(hù)的等待隊(duì)列，如果為空火诸，或者當(dāng)前線程是等待隊(duì)列的第一個(gè)就占有鎖灵份，否者就會(huì)加入到等待隊(duì)列中扬跋，以后會(huì)按照 FIFO 的規(guī)則獲取鎖
?非公平鎖：一上來就嘗試占有鎖脆栋，如果失敗在進(jìn)行排隊(duì)
代碼示例

/**
     * Creates an instance of {@code ReentrantLock}.
     * This is equivalent to using {@code ReentrantLock(false)}.
     */
    public ReentrantLock() {
        sync = new NonfairSync();
    }

    /**
     * Creates an instance of {@code ReentrantLock} with the
     * given fairness policy.
     *
     * @param fair {@code true} if this lock should use a fair ordering policy
     */
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

ReentrantLock的構(gòu)造方法中可傳入一個(gè)boolean值，表示是否是公平鎖鸠匀。默認(rèn)為非公平鎖蕉斜。 synchronized是一種非公平鎖。

2.可重入鎖（遞歸鎖）和不可重入鎖

?可重入鎖：指的是同一個(gè)線程外層函數(shù)獲得鎖之后狮崩，內(nèi)層仍然能獲取到該鎖蛛勉，在同一個(gè)線程在外層方法獲取鎖的時(shí)候，在進(jìn)入內(nèi)層方法或會(huì)自動(dòng)獲取該鎖睦柴。
?不可重入鎖： 若當(dāng)前線程執(zhí)行某個(gè)方法已經(jīng)獲取了該鎖诽凌，那么在方法中嘗試再次獲取鎖時(shí)，就會(huì)獲取不到被阻塞坦敌。
代碼示例

public class ReentrantLockDemo {
    public static void main(String[] args) {
        method1();
    }
    public static synchronized void method1(){
        System.out.println("method1執(zhí)行");
        method2();
    }

    public static synchronized void method2(){
        System.out.println("method2執(zhí)行");
    }
}

?在main方法中調(diào)用method1()發(fā)現(xiàn)兩個(gè)方法都執(zhí)行了侣诵，說明synchronized是可重入鎖。ReentrantLock也是可重入鎖狱窘。

3.自旋鎖 類似CAS

?嘗試獲取鎖的線程不會(huì)立即堵塞杜顺，而是采用循環(huán)的方式去嘗試獲取鎖，這樣的好處是減少線程上線文切換的消耗蘸炸，缺點(diǎn)就是循環(huán)會(huì)消耗 CPU躬络。
代碼示例

import java.util.concurrent.atomic.AtomicReference;

public class SpinLockTest {
    public static void main(String[] args) {
        SpinLock spinLock = new SpinLock();
        new Thread(new Runnable() {
            @Override
            public void run() {
                spinLock.lock();
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("------------");
                spinLock.unlock();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                spinLock.lock();
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("++++++++++++");
                spinLock.unlock();
            }
        }).start();

    }
}

class SpinLock {
   private AtomicReference<Thread> atomicReference = new AtomicReference();
    public void lock() {
        Thread thread = Thread.currentThread();
        while (!atomicReference.compareAndSet(null, thread)) {

        }
        System.out.println(thread.getName() + "獲取鎖");
    }
    public void unlock() {
        Thread thread = Thread.currentThread();
        atomicReference.compareAndSet(thread, null);
        System.out.println(thread.getName() + "釋放鎖");
    }
}
/*
Thread-0獲取鎖
------------
Thread-0釋放鎖
Thread-1獲取鎖
++++++++++++
Thread-1釋放鎖
*/

輸出結(jié)果表示加鎖成功。獲取鎖的時(shí)候搭儒，如果原子引用為空就獲取鎖穷当，不為空表示有人獲取了鎖，就循環(huán)等待淹禾。

4.獨(dú)占鎖與共享鎖（讀寫鎖）

?獨(dú)占鎖：指該鎖一次只能被一個(gè)線程持有
?共享鎖：該鎖可以被多個(gè)線程持有
?Java中的ReentrantLock和synchronized都是獨(dú)占鎖馁菜。ReentrantReadWriteLock中的ReadLock是共享鎖，WriteLock是獨(dú)占鎖铃岔。多個(gè)線程可以同時(shí)持有ReadLock汪疮，讀寫·寫讀·寫寫都是互斥的。
代碼示例

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReentrantReadWriteLockTest {

    public static void main(String[] args) {
        ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
        List list = new ArrayList();


        for(int i = 0;i < 20 ; i++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    readWriteLock.writeLock().lock();
                    System.out.println(Thread.currentThread() + "寫開始");
                    list.add(Math.round(Math.random()*100));
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread() + "寫結(jié)束");
                    readWriteLock.writeLock().unlock();
                }
            }).start();

        }

        for(int i = 0;i < 20 ; i++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    readWriteLock.readLock().lock();
                    System.out.println(Thread.currentThread() + "讀開始");
                    System.out.println(list);
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread() + "讀結(jié)束");
                    readWriteLock.readLock().unlock();
                }
            }).start();
        }
    }
}

5.synchronized 和 Lock

原始結(jié)構(gòu)
??synchronized 是關(guān)鍵字屬于 JVM 層面毁习，反應(yīng)在字節(jié)碼上是 monitorenter 和 monitorexit智嚷，其底層是通過 monitor 對(duì)象來完成，其實(shí) wait/notify 等方法也是依賴 monitor 對(duì)象只有在同步快或方法中才能調(diào)用 wait/notify 等方法纺且。
??Lock 是具體類（java.util.concurrent.locks.Lock）是 api 層面的鎖纤勒。
使用方法
??synchronized 不需要用戶手動(dòng)去釋放鎖，當(dāng) synchronized 代碼執(zhí)行完后系統(tǒng)會(huì)自動(dòng)讓線程釋放對(duì)鎖的占用隆檀。
??ReentrantLock 則需要用戶手動(dòng)的釋放鎖，若沒有主動(dòng)釋放鎖，可能導(dǎo)致出現(xiàn)死鎖的現(xiàn)象恐仑，lock() 和 unlock() 方法需要配合 try/finally 語句來完成泉坐。
等待是否可中斷
??synchronized 不可中斷，除非拋出異成哑停或者正常運(yùn)行完成腕让。
??ReentrantLock 可中斷，設(shè)置超時(shí)方法 tryLock(long timeout, TimeUnit unit)歧斟，lockInterruptibly() 放代碼塊中纯丸，調(diào)用 interrupt() 方法可中斷。
加鎖是否公平
??synchronized 非公平鎖
??ReentrantLock 默認(rèn)非公平鎖静袖，構(gòu)造方法中可以傳入 boolean 值觉鼻，true 為公平鎖，false 為非公平鎖队橙。
鎖可以綁定多個(gè) Condition
??synchronized 沒有 Condition坠陈。
??ReentrantLock 用來實(shí)現(xiàn)分組喚醒需要喚醒的線程們，可以精確喚醒捐康，而不是像 synchronized 要么隨機(jī)喚醒一個(gè)線程要么喚醒全部線程仇矾。

JDK1.6以后溺蕉，為了減少獲得鎖和釋放鎖所帶來的性能消耗伶丐，提高性能，引入了“輕量級(jí)鎖”和“偏向鎖”疯特。官方更建議使用synchronized哗魂。詳情見Java中的偏向鎖，輕量級(jí)鎖漓雅， 重量級(jí)鎖解析

代碼示例:synchronized實(shí)現(xiàn)生產(chǎn)消費(fèi)模型

import java.util.concurrent.TimeUnit;

public class ProdConsume_Synchronized {
    private int count = 0;
    public static final int FULL = 10;
    private volatile boolean flag = true;
    private Object lock;

    public ProdConsume_Synchronized(Object lock) {
        this.lock = lock;
    }

    public static void main(String[] args) {
        Object lock = new Object();
        ProdConsume_Synchronized prodConsume_synchronized = new ProdConsume_Synchronized(lock);
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    prodConsume_synchronized.consume();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    prodConsume_synchronized.prod();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

        try {
            TimeUnit.SECONDS.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        prodConsume_synchronized.flag = false;
    }

    public void prod() throws InterruptedException {
        while (flag) {
            synchronized (lock) {
                while (count == FULL) {
                    lock.wait();
                }
                count++;
                long round = Math.round(Math.random() * 1000);
                Thread.sleep(round);
                System.out.println(round + "號(hào)商品生產(chǎn)完畢录别，還有" + count + "個(gè)商品");
                lock.notifyAll();

            }
        }
    }

    public void consume() throws InterruptedException {
        while (flag) {
            synchronized (lock) {
                while (count == 0) {
                    lock.wait();
                }
                count--;
                Thread.sleep(500);
                System.out.println("取走一個(gè)商品朽色，還有" + count + "個(gè)商品");
                lock.notifyAll();

            }
        }
    }
}

輸出結(jié)果

643號(hào)商品生產(chǎn)完畢，還有1個(gè)商品
322號(hào)商品生產(chǎn)完畢组题，還有2個(gè)商品
819號(hào)商品生產(chǎn)完畢葫男，還有3個(gè)商品
877號(hào)商品生產(chǎn)完畢，還有4個(gè)商品
112號(hào)商品生產(chǎn)完畢崔列，還有5個(gè)商品
904號(hào)商品生產(chǎn)完畢梢褐，還有6個(gè)商品
978號(hào)商品生產(chǎn)完畢，還有7個(gè)商品
569號(hào)商品生產(chǎn)完畢赵讯，還有8個(gè)商品
949號(hào)商品生產(chǎn)完畢盈咳，還有9個(gè)商品
661號(hào)商品生產(chǎn)完畢，還有10個(gè)商品
取走一個(gè)商品边翼，還有9個(gè)商品
取走一個(gè)商品鱼响，還有8個(gè)商品
取走一個(gè)商品，還有7個(gè)商品
取走一個(gè)商品讯私，還有6個(gè)商品
取走一個(gè)商品热押，還有5個(gè)商品
取走一個(gè)商品，還有4個(gè)商品
取走一個(gè)商品斤寇，還有3個(gè)商品
124號(hào)商品生產(chǎn)完畢桶癣，還有4個(gè)商品

代碼示例:ReentrantLock實(shí)現(xiàn)生產(chǎn)消費(fèi)模型

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ProdConsume_ReentrantLock {
    private int count = 0;
    public static final int FULL = 10;
    private volatile boolean flag = true;
    private Lock lock = new ReentrantLock();
    private Condition condition_prod = lock.newCondition();
    private Condition condition_consume = lock.newCondition();

    public static void main(String[] args) {
        ProdConsume_ReentrantLock prodConsume_reentrantLock = new ProdConsume_ReentrantLock();
        for (int i = 0; i < 3; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    prodConsume_reentrantLock.prod();
                }
            }).start();
        }


        for (int i = 0; i < 3; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    prodConsume_reentrantLock.consume();
                }
            }).start();
        }


        try {
            TimeUnit.SECONDS.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        prodConsume_reentrantLock.flag = false;
    }

    public void prod() {
        while (flag) {
            try {
                lock.lock();
                try {
                    while (count == FULL) {
                        condition_prod.await();
                    }
                    count++;
                    long round = Math.round(Math.random() * 1000);
                    Thread.sleep(round);
                    System.out.println(round + "號(hào)商品生產(chǎn)完畢，還有" + count + "個(gè)商品");
                    condition_consume.signalAll();
                } catch (Exception e) {
                    e.printStackTrace();
                }

            } finally {
                lock.unlock();
            }
        }
    }

    public void consume() {
        while (flag) {
            try {
                lock.lock();
                try {
                    while (count == 0) {
                        condition_consume.await();
                    }
                    count--;
                    Thread.sleep(500);
                    System.out.println("取走一個(gè)商品娘锁，還有" + count + "個(gè)商品");
                    condition_prod.signalAll();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            } finally {
                lock.unlock();
            }
        }
    }
}

代碼示例:ReentrantLock實(shí)現(xiàn)精準(zhǔn)喚醒

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class PrecisionWeakUp_ReentrantLock {
    private final Lock lock = new ReentrantLock();
    private Condition conditionA = lock.newCondition();
    private Condition conditionB = lock.newCondition();
    private Condition conditionC = lock.newCondition();
    private int flag = 1;

    // 多線程下先輸出五次A 再輸出五次B 再輸出五次C
    public static void main(String[] args) {
        PrecisionWeakUp_ReentrantLock precisionWeakUp_reentrantLock = new PrecisionWeakUp_ReentrantLock();
        for(int i = 0;i < 3;i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        precisionWeakUp_reentrantLock.printA();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }

        for(int i = 0;i < 3;i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        precisionWeakUp_reentrantLock.printB();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }

        for(int i = 0;i < 3;i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        precisionWeakUp_reentrantLock.printC();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }

    }

    public void printA() throws InterruptedException {
        try {
            lock.lock();
            while (flag != 1) {
                conditionA.await();
            }
            for (int i = 0; i < 5; i++) {
                System.out.println("A");
            }
            flag = 2;
            conditionB.signalAll();
        }finally {
            lock.unlock();
        }
    }
    public void printB() throws InterruptedException {
        try {
            lock.lock();
            while (flag != 2) {
                conditionB.await();
            }
            for (int i = 0; i < 5; i++) {
                System.out.println("B");
            }
            flag = 3;
            conditionC.signalAll();
        }finally {
            lock.unlock();
        }
    }
    public void printC() throws InterruptedException {
        try {
            lock.lock();
            while (flag != 3) {
                conditionC.await();
            }
            for (int i = 0; i < 5; i++) {
                System.out.println("C");
            }
            flag = 1;
            conditionA.signalAll();
        }finally {
            lock.unlock();
        }
    }
}

四 .JUC包的并發(fā)工具類

1.CountDownLatch

?CountDownLatch中count down是倒數(shù)的意思牙寞，latch則是門閂的含義。整體含義可以理解為倒數(shù)的門栓莫秆。在構(gòu)造CountDownLatch的時(shí)候需要傳入一個(gè)整數(shù)n间雀，在這個(gè)整數(shù)“倒數(shù)”到0之前，主線程需要等待在門口镊屎，而這個(gè)“倒數(shù)”過程則是由各個(gè)執(zhí)行線程驅(qū)動(dòng)的惹挟，每個(gè)線程執(zhí)行完一個(gè)任務(wù)“倒數(shù)”一次》觳担總結(jié)來說连锯，CountDownLatch的作用就是等待其他的線程都執(zhí)行完任務(wù)，必要時(shí)可以對(duì)各個(gè)任務(wù)的執(zhí)行結(jié)果進(jìn)行匯總用狱，然后主線程才繼續(xù)往下執(zhí)行运怖。
? CountDownLatch主要有兩個(gè)方法：countDown()和await()。countDown()方法用于使計(jì)數(shù)器減一夏伊，其一般是執(zhí)行任務(wù)的線程調(diào)用摇展，await()方法則使調(diào)用該方法的線程處于等待狀態(tài)，其一般是主線程調(diào)用溺忧。這里需要注意的是咏连，countDown()方法并沒有規(guī)定一個(gè)線程只能調(diào)用一次盯孙，當(dāng)同一個(gè)線程調(diào)用多次countDown()方法時(shí)，每次都會(huì)使計(jì)數(shù)器減一祟滴；另外镀梭，await()方法也并沒有規(guī)定只能有一個(gè)線程執(zhí)行該方法，如果多個(gè)線程同時(shí)執(zhí)行await()方法踱启，那么這幾個(gè)線程都將處于等待狀態(tài)，并且以共享模式享有同一個(gè)鎖研底。
代碼示例

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

public class CountDownLatchDemo {
    public static void main(String[] args) {
        List list = new ArrayList();
        List synchronizedList = Collections.synchronizedList(list);
        CountDownLatch countDownLatch = new CountDownLatch(5);
        for(int i = 0;i < 5;i++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    long round = Math.round(Math.random() * 100);
                    synchronizedList.add(round);
                    System.out.println(round + "添加進(jìn)List");
                    countDownLatch.countDown();

                }
            }).start();
        }

        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(synchronizedList);
    }
}

輸出結(jié)果

68添加進(jìn)List
91添加進(jìn)List
57添加進(jìn)List
12添加進(jìn)List
98添加進(jìn)List
[68, 57, 12, 98, 91]

?CountDownLatch非常適合于對(duì)任務(wù)進(jìn)行拆分埠偿，使其并行執(zhí)行，比如某個(gè)任務(wù)執(zhí)行2s榜晦，其對(duì)數(shù)據(jù)的請(qǐng)求可以分為五個(gè)部分冠蒋，那么就可以將這個(gè)任務(wù)拆分為5個(gè)子任務(wù)，分別交由五個(gè)線程執(zhí)行乾胶，執(zhí)行完成之后再由主線程進(jìn)行匯總抖剿，此時(shí)，總的執(zhí)行時(shí)間將決定于執(zhí)行最慢的任務(wù)识窿，平均來看斩郎，還是大大減少了總的執(zhí)行時(shí)間。

2. CyclicBarrier

?CyclicBarrier同步屏障喻频，可以讓一組線程達(dá)到一個(gè)屏障時(shí)被阻塞缩宜，直到最后一個(gè)線程達(dá)到屏障時(shí)，所以被阻塞的線程才能繼續(xù)執(zhí)行甥温。
?CyclicBarrier好比一扇門锻煌，默認(rèn)情況下關(guān)閉狀態(tài)，堵住了線程執(zhí)行的道路姻蚓，直到所有線程都就位宋梧，門才打開，讓所有線程一起通過狰挡。
CyclicBarrier的構(gòu)造方法
?1.CyclicBarrier(int parties)：創(chuàng)建一個(gè)新的 CyclicBarrier捂龄，它將在給定數(shù)量的參與者（線程）處于等待狀態(tài)時(shí)啟動(dòng)，但它不會(huì)在啟動(dòng) barrier 時(shí)執(zhí)行預(yù)定義的操作圆兵。
?2.CyclicBarrier(int parties, Runnable barrierAction) ：創(chuàng)建一個(gè)新的 CyclicBarrier跺讯，它將在給定數(shù)量的參與者（線程）處于等待狀態(tài)時(shí)啟動(dòng)，并在啟動(dòng) barrier 時(shí)執(zhí)行給定的屏障操作殉农，該操作由最后一個(gè)進(jìn)入 barrier 的線程執(zhí)行刀脏。

代碼示例

import java.util.concurrent.BrokenBarrierException;
        import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierDemo {
    public static void main(String[] args) {
        //景區(qū)觀光車循環(huán)發(fā)車，每一輛車一個(gè)五個(gè)座位超凳，坐滿發(fā)車
        CyclicBarrier cyclicBarrier = new CyclicBarrier(5, new Runnable() {
            @Override
            public void run() {
                System.out.println("人員已到位愈污，出發(fā)");
            }
        });

        for(int i = 1;i <= 5;i++){
            final int n = i;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(n + "號(hào)游客上車");
                    try {
                        cyclicBarrier.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }

        for(int i = 6;i <= 10;i++){
            final int n = i;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(n + "號(hào)游客上車");
                    try {
                        cyclicBarrier.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }
}

輸出結(jié)果

1號(hào)游客上車
3號(hào)游客上車
2號(hào)游客上車
5號(hào)游客上車
4號(hào)游客上車
人員已到位耀态，出發(fā)
6號(hào)游客上車
7號(hào)游客上車
8號(hào)游客上車
9號(hào)游客上車
10號(hào)游客上車
人員已到位，出發(fā)

?每當(dāng)線程執(zhí)行await暂雹，內(nèi)部變量count減1首装，如果count！= 0杭跪，說明有線程還未到屏障處仙逻，則在鎖條件變量trip上等待。
?當(dāng)count == 0時(shí)涧尿，說明所有線程都已經(jīng)到屏障處系奉，執(zhí)行條件變量的signalAll方法喚醒等待的線程。

CountDownLatch與CyclicBarrier比較

3.Semaphore

?ReentrantLock和Synchronized一次都只允許一個(gè)線程訪問一個(gè)資源号阿。Semaphore允許多個(gè)線程同時(shí)訪問同一個(gè)資源并鸵。
?Semaphore管理著一組許可（permit），許可的初始數(shù)量可以通過構(gòu)造函數(shù)設(shè)定倦西，操作時(shí)首先要獲取到許可能真，才能進(jìn)行操作，操作完成后需要釋放許可扰柠。如果沒有獲取許可粉铐，則阻塞到有許可被釋放。如果初始化了一個(gè)許可為1的Semaphore卤档，那么就相當(dāng)于一個(gè)不可重入的互斥鎖蝙泼。其中0、1就相當(dāng)于它的狀態(tài)劝枣，當(dāng)=1時(shí)表示其他線程可以獲取汤踏，當(dāng)=0時(shí)，排他舔腾，即其他線程必須要等待溪胶。
Semaphore的構(gòu)造方法
?1.Semaphore(int permits) ：創(chuàng)建具有給定的許可數(shù)和非公平的公平設(shè)置的 Semaphore，默認(rèn)非公平鎖稳诚。
?2.Semaphore(int permits, boolean fair) ：創(chuàng)建具有給定的許可數(shù)和給定的公平設(shè)置的 Semaphore哗脖。
代碼示例

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

public class SemaphoreDemo {
    public static void main(String[] args) {
        // 六個(gè)車搶三個(gè)車位
        Semaphore semaphore = new Semaphore(3);
        for(int i = 1;i <= 6;i++){
            final int n = i;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        semaphore.acquire();
                        System.out.println(n + "號(hào)搶到車位——————————");
                        TimeUnit.SECONDS.sleep(2);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }finally {
                        System.out.println(n + "號(hào)離開車位++++++++++");
                        semaphore.release();
                    }
                }
            }).start();
        }
    }
}

輸出結(jié)果

1號(hào)搶到車位——————————
2號(hào)搶到車位——————————
3號(hào)搶到車位——————————
2號(hào)離開車位++++++++++
1號(hào)離開車位++++++++++
3號(hào)離開車位++++++++++
4號(hào)搶到車位——————————
6號(hào)搶到車位——————————
5號(hào)搶到車位——————————
6號(hào)離開車位++++++++++
4號(hào)離開車位++++++++++
5號(hào)離開車位++++++++++

?Semaphore在限制流量方面有非常多的應(yīng)用，比如程序跑批高峰時(shí)幾萬個(gè)數(shù)據(jù)庫的連接同時(shí)操作，為了不影響其他用戶訪問只允許同時(shí)開放十條連接才避。

四.線程安全的集合類

?Java中的集合包括三大類橱夭，它們是Set、List和Map它們都處于java.util包中桑逝，Set棘劣、List和Map都是接口，它們有各自的實(shí)現(xiàn)類楞遏。

1.List（列表）

?實(shí)現(xiàn)類主要有ArrayList茬暇，LinkedList，Vector
?ArrayList,LinkedList為線程不安全的集合類寡喝，ArrayList底層是數(shù)組而LinkedList底層實(shí)現(xiàn)為鏈表而钞。Vector和ArrayList類似，是長度可變的數(shù)組拘荡。Vector是線程安全的，它給幾乎所有的public方法都加上了synchronized關(guān)鍵字撬陵。由于加鎖導(dǎo)致性能降低珊皿，在不需要并發(fā)訪問同一對(duì)象時(shí)，這種強(qiáng)制性的同步機(jī)制就顯得多余巨税，所以現(xiàn)在Vector已被棄用蟋定。

2.Set（集）

?實(shí)現(xiàn)類主要有HashSet，TreeSet
?HashSet是一個(gè)無序的集合草添，基于HashMap實(shí)現(xiàn)驶兜；TreeSet是一個(gè)有序的集合，基于TreeMap實(shí)現(xiàn)远寸。HashSet集合中允許有null元素抄淑，TreeSet集合中不允許有null元素。HashSet和TreeSet都是線程不安全的驰后。

3.Map（映射）

?實(shí)現(xiàn)類主要有HashMap肆资，TreeMap，HashTable
?HashTable和HashMap類似灶芝，不同點(diǎn)是HashTable是線程安全的郑原，它給幾乎所有public方法都加上了synchronized關(guān)鍵字，還有一個(gè)不同點(diǎn)是HashTable的K夜涕，V都不能是null犯犁，但HashMap可以，它現(xiàn)在也因?yàn)樾阅茉虮粭売门鳌reeMap也是線程不安全的酸役。

4.除廢棄的集合類外還有哪些方法可以保證線程安全

?1.Collections包裝方法
??Collections工具類中提供了相應(yīng)的包裝方法把它們包裝成線程安全的集合

List<E> synArrayList = Collections.synchronizedList(new ArrayList<E>());
Set<E> synHashSet = Collections.synchronizedSet(new HashSet<E>());
Map<K,V> synHashMap = Collections.synchronizedMap(new HashMap<K,V>());

?2.java.util.concurrent包中的集合
??CopyOnWriteArrayList和CopyOnWriteArraySet
?? ?CopyOnWriteArrayList 中的set、add、remove等方法簇捍，都使用了ReentrantLock的lock來加鎖只壳， unlock來解鎖當(dāng)增加元素的時(shí)候使用Arrays.copyOf()來拷貝副本，在副本上增加元素暑塑，然后改變原來引用的指向副本吼句。讀操作不需要加鎖，因此事格，CopyOnWriteArrayList類是一個(gè)線程安全的List接口實(shí)現(xiàn)惕艳，這對(duì)于讀操作遠(yuǎn)遠(yuǎn)多于寫操作的應(yīng)用非常適合，特別是在并發(fā)的情況下驹愚，可以提供高性能的并發(fā)讀取远搪，并保證讀取的內(nèi)容一定是正確的，不受多線程并發(fā)問題的影響逢捺。
?? ConcurrentHashMap
? ? ? 1.8版本的ConcurrentHashMap拋棄了原有的 Segment 分段鎖谁鳍，而采用了 CAS + synchronized 來保證并發(fā)安全性。詳情見HashMap? ConcurrentHashMap? 相信看完這篇沒人能難住你劫瞳！

5.CopyOnWrite機(jī)制

??CopyOnWrite容器即寫是復(fù)制的容器倘潜。通俗的理解就是當(dāng)我們往一個(gè)容器添加元素的時(shí)候，不直接往當(dāng)前容器添加志于，而是先將當(dāng)前容器進(jìn)行Copy涮因，復(fù)制出一個(gè)新的容器，然后新的容器里添加元素伺绽，添加完元素后养泡，再將原容器的引用指向新的容器。這樣做的好處就是我們可以對(duì)CopyOnWrite容器進(jìn)行并發(fā)的讀奈应，而不需要加鎖澜掩，因?yàn)楫?dāng)前容器不會(huì)添加任何元素.所以，CopyOnWrite容器也是一種讀寫分離的思想杖挣。讀和寫不容的容器输硝。
??ArrayList里添加元素，在添加的時(shí)候是需要加鎖的程梦，否則多線程寫的時(shí)候會(huì)copy出多個(gè)副本出來
讀的時(shí)候不需要加鎖点把，如果讀的時(shí)候有多線程正在像ArrayList中添加數(shù)據(jù)，還是會(huì)讀到舊的數(shù)據(jù)屿附，因?yàn)閷懙臅r(shí)候不會(huì)鎖住舊的ArrayList
??1郎逃、使用場景：讀多寫少
??2、使用注意點(diǎn)：減少擴(kuò)容開銷挺份；b褒翰、使用批量添加
?缺點(diǎn)：
??a、內(nèi)存占用問題
??b、數(shù)據(jù)一致性問題

五.BlockingQueue（阻塞隊(duì)列）

?在某些情況下對(duì)阻塞隊(duì)列的訪問可能會(huì)造成阻塞优训。被阻塞的情況主要有如下兩種:
??1朵你、當(dāng)阻塞隊(duì)列是空時(shí)，從隊(duì)列中獲取元素的操作將會(huì)被阻塞揣非。
??2抡医、當(dāng)阻塞隊(duì)列是滿時(shí)，往隊(duì)列里添加元素的操作將會(huì)被阻塞早敬。
?當(dāng)一個(gè)線程對(duì)已經(jīng)滿了的阻塞隊(duì)列進(jìn)行入隊(duì)操作時(shí)會(huì)阻塞忌傻，除非有另外一個(gè)線程進(jìn)行了出隊(duì)操作，當(dāng)一個(gè)線程對(duì)一個(gè)空的阻塞隊(duì)列進(jìn)行出隊(duì)操作時(shí)也會(huì)阻塞搞监，除非有另外一個(gè)線程進(jìn)行了入隊(duì)操作水孩。

?這四類方法分別對(duì)應(yīng)的是：
??1、ThrowsException ：如果操作不能馬上進(jìn)行琐驴，則拋出異常
??2俘种、SpecialValue ：如果操作不能馬上進(jìn)行，將會(huì)返回一個(gè)特殊的值绝淡，一般是true或者false
??3安疗、Blocks : 如果操作不能馬上進(jìn)行，操作會(huì)被阻塞
??4够委、TimesOut : 如果操作不能馬上進(jìn)行，操作會(huì)被阻塞指定的時(shí)間怖现，如果指定時(shí)間沒執(zhí)行茁帽，則返回一個(gè)特殊值，一般是true或者false
?插入方法
??add(E e)：添加成功返回true屈嗤，失敗拋 IllegalStateException 異常
??offer(E e)：成功返回 true潘拨，如果此隊(duì)列已滿，則返回 false
??put(E e)：將元素插入此隊(duì)列的尾部饶号，如果該隊(duì)列已滿铁追，則一直阻塞
?刪除方法
??remove(Object o) ：移除指定元素,成功返回true，失敗返回false
??poll()：獲取并移除此隊(duì)列的頭元素茫船，若隊(duì)列為空琅束，則返回 null
??take()：獲取并移除此隊(duì)列頭元素，若沒有元素則一直阻塞
?檢查方法
??element() ：獲取但不移除此隊(duì)列的頭元素算谈，沒有元素則拋異常
??peek() :獲取但不移除此隊(duì)列的頭涩禀；若隊(duì)列為空，則返回 null

BlockingQueue的七個(gè)實(shí)現(xiàn)類

??1然眼、ArrayBlockingQueue ：一個(gè)由數(shù)組結(jié)構(gòu)組成的有界阻塞隊(duì)列艾船。
??2、LinkedBlockingQueue ：一個(gè)由鏈表結(jié)構(gòu)組成的有界阻塞隊(duì)列。
??3屿岂、PriorityBlockingQueue ：一個(gè)支持優(yōu)先級(jí)排序的無界阻塞隊(duì)列践宴。
??4、DelayQueue：一個(gè)使用優(yōu)先級(jí)隊(duì)列實(shí)現(xiàn)的無界阻塞隊(duì)列爷怀。
??5阻肩、SynchronousQueue：一個(gè)不存儲(chǔ)元素的阻塞隊(duì)列。
??6霉撵、LinkedTransferQueue：一個(gè)由鏈表結(jié)構(gòu)組成的無界阻塞隊(duì)列磺浙。
??7、LinkedBlockingDeque：一個(gè)由鏈表結(jié)構(gòu)組成的雙向阻塞隊(duì)列徒坡。
??注意：第七個(gè)實(shí)現(xiàn)類的末尾為Deque
??詳細(xì)信息Java并發(fā)編程-阻塞隊(duì)列(BlockingQueue)的實(shí)現(xiàn)原理

代碼示例:BlockingQueue實(shí)現(xiàn)生產(chǎn)消費(fèi)模型

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class ProdConsume_BlockingQueue {

    private AtomicInteger atomicInteger = new AtomicInteger();
    private BlockingQueue blockingQueue;
    private volatile boolean flag = true;


    public ProdConsume_BlockingQueue(BlockingQueue blockingQueue) {
        this.blockingQueue = blockingQueue;
    }

    public void prod() {
        while (flag) {
            try {
                long round = Math.round(Math.random() * 1000);
                Thread.sleep(round);
                blockingQueue.put(round);
                int i = atomicInteger.incrementAndGet();
                System.out.println(round + "號(hào)商品生產(chǎn)完畢放入隊(duì)列撕氧，隊(duì)列中還有" + i + "個(gè)商品");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public void consum() {
        while (flag) {
            try {
                Thread.sleep(500);
                Object take = blockingQueue.take();
                atomicInteger.decrementAndGet();
                System.out.println(take + "號(hào)商品被購買");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        BlockingQueue blockingQueue = new ArrayBlockingQueue(100);
        ProdConsume_BlockingQueue prodConsume_blockingQueue = new ProdConsume_BlockingQueue(blockingQueue);

        new Thread(new Runnable() {
            @Override
            public void run() {
                prodConsume_blockingQueue.prod();
            }
        }).start();


        new Thread(new Runnable() {
            @Override
            public void run() {
                prodConsume_blockingQueue.consum();
            }
        }).start();

        try {
            TimeUnit.SECONDS.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        prodConsume_blockingQueue.flag = false;
    }
}

輸出結(jié)果

180號(hào)商品生產(chǎn)完畢放入隊(duì)列，隊(duì)列中還有1個(gè)商品
180號(hào)商品被購買
331號(hào)商品生產(chǎn)完畢放入隊(duì)列喇完，隊(duì)列中還有1個(gè)商品
201號(hào)商品生產(chǎn)完畢放入隊(duì)列伦泥，隊(duì)列中還有2個(gè)商品
331號(hào)商品被購買
201號(hào)商品被購買
897號(hào)商品生產(chǎn)完畢放入隊(duì)列，隊(duì)列中還有1個(gè)商品
897號(hào)商品被購買
588號(hào)商品生產(chǎn)完畢放入隊(duì)列锦溪，隊(duì)列中還有1個(gè)商品
217號(hào)商品生產(chǎn)完畢放入隊(duì)列不脯，隊(duì)列中還有2個(gè)商品
588號(hào)商品被購買
154號(hào)商品生產(chǎn)完畢放入隊(duì)列，隊(duì)列中還有2個(gè)商品
217號(hào)商品被購買
592號(hào)商品生產(chǎn)完畢放入隊(duì)列刻诊，隊(duì)列中還有2個(gè)商品
154號(hào)商品被購買
442號(hào)商品生產(chǎn)完畢放入隊(duì)列防楷，隊(duì)列中還有2個(gè)商品
592號(hào)商品被購買
712號(hào)商品生產(chǎn)完畢放入隊(duì)列，隊(duì)列中還有2個(gè)商品
442號(hào)商品被購買
712號(hào)商品被購買
893號(hào)商品生產(chǎn)完畢放入隊(duì)列则涯，隊(duì)列中還有1個(gè)商品
15號(hào)商品生產(chǎn)完畢放入隊(duì)列，隊(duì)列中還有2個(gè)商品
893號(hào)商品被購買
496號(hào)商品生產(chǎn)完畢放入隊(duì)列亿昏，隊(duì)列中還有2個(gè)商品
4號(hào)商品生產(chǎn)完畢放入隊(duì)列档礁，隊(duì)列中還有3個(gè)商品
15號(hào)商品被購買
534號(hào)商品生產(chǎn)完畢放入隊(duì)列，隊(duì)列中還有3個(gè)商品
172號(hào)商品生產(chǎn)完畢放入隊(duì)列递礼，隊(duì)列中還有4個(gè)商品
496號(hào)商品被購買
4號(hào)商品被購買
891號(hào)商品生產(chǎn)完畢放入隊(duì)列宰衙，隊(duì)列中還有3個(gè)商品
534號(hào)商品被購買
414號(hào)商品生產(chǎn)完畢放入隊(duì)列睹欲，隊(duì)列中還有3個(gè)商品
172號(hào)商品被購買
891號(hào)商品被購買
920號(hào)商品生產(chǎn)完畢放入隊(duì)列供炼，隊(duì)列中還有2個(gè)商品
71號(hào)商品生產(chǎn)完畢放入隊(duì)列一屋，隊(duì)列中還有3個(gè)商品
144號(hào)商品生產(chǎn)完畢放入隊(duì)列，隊(duì)列中還有4個(gè)商品
414號(hào)商品被購買
586號(hào)商品生產(chǎn)完畢放入隊(duì)列袋哼，隊(duì)列中還有4個(gè)商品
920號(hào)商品被購買
71號(hào)商品被購買
553號(hào)商品生產(chǎn)完畢放入隊(duì)列冀墨，隊(duì)列中還有3個(gè)商品

五.實(shí)現(xiàn)多線程的幾種方式

? 1. 繼承Thread類，重寫run方法

? ? 略

? 2. 實(shí)現(xiàn)Runnable接口涛贯，重寫run方法

? ? 略

? 3. 實(shí)現(xiàn)Callable接口诽嘉，重寫call方法，通過FutureTask包裝器來創(chuàng)建Thread線程

? ? Runnable和Callable的區(qū)別：
? ??1弟翘、Callable規(guī)定的方法是call(),Runnable規(guī)定的方法是run().
? ??2虫腋、Callable的任務(wù)執(zhí)行后可返回值，而Runnable的任務(wù)是不能返回值得
? ??3稀余、call方法可以拋出異常悦冀，run方法不可以
? ??4、運(yùn)行Callable任務(wù)可以拿到一個(gè)Future對(duì)象睛琳，表示異步計(jì)算的結(jié)果盒蟆。它提供了檢查計(jì)算是否完成的方法，以等待計(jì)算的完成师骗，并檢索計(jì)算的結(jié)果历等。通過Future對(duì)象可以了解任務(wù)執(zhí)行情況寒屯，可取消任務(wù)的執(zhí)行寡夹，還可獲取執(zhí)行結(jié)果鸳君。
? ? Future接口
? ?? Future是一個(gè)接口渡讼，代表了一個(gè)異步計(jì)算的結(jié)果讹躯。接口中的方法用來檢查計(jì)算是否完成、等待完成和得到計(jì)算的結(jié)果平挑。
? ??當(dāng)計(jì)算完成后，只能通過get()方法得到結(jié)果找都，get方法會(huì)阻塞直到結(jié)果準(zhǔn)備好了能耻。
? ??如果想取消，那么調(diào)用cancel()方法戒职。其他方法用于確定任務(wù)是正常完成還是取消了帕涌。一旦計(jì)算完成了蚓曼，那么這個(gè)計(jì)算就不能被取消纫版。
??FutureTask類
? ?? FutureTask類實(shí)現(xiàn)了RunnableFuture接口，而RunnnableFuture接口繼承了Runnable和Future接口梭伐，所以說FutureTask是一個(gè)提供異步計(jì)算的結(jié)果的任務(wù)糊识。
? ??FutureTask可以用來包裝Callable或者Runnbale對(duì)象赂苗。因?yàn)镕utureTask實(shí)現(xiàn)了Runnable接口拌滋，所以FutureTask也可以被提交給Executor败砂。
??Callable兩種執(zhí)行方式
? ?1锡垄、借助FutureTask執(zhí)行
? ??FutureTask類同時(shí)實(shí)現(xiàn)了兩個(gè)接口货岭，F(xiàn)uture和Runnable接口千贯，所以它既可以作為Runnable被線程執(zhí)行搔谴，又可以作為Future得到Callable的返回值敦第。

? ?代碼示例

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

public class CallableDemo {
    public static void main(String[] args) {
        FutureTask<Integer> futureTask = new FutureTask<>(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                System.out.println("Callable");
                Thread.sleep(1000);
                return (int)(Math.random()*100);
            }
        });
        futureTask.run();
        //如果沒有執(zhí)行完一直阻塞
        while (!futureTask.isDone()){
        }
        Integer integer = null;
        try {
            integer = futureTask.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println(integer);
    }
}

? ?2、借助線程池來運(yùn)行
? ????????↓

? 4. 線程池ThreadPoolExecuter

? ????????↓

六.線程池ThreadPoolExecutor

? 線程池主要是控制運(yùn)行線程的數(shù)量右钾，處理過程中將任務(wù)放入隊(duì)列舀射，然后在線程創(chuàng)建后啟動(dòng)這些任務(wù)脆烟，如果線程數(shù)量超過了最大數(shù)量的線程排隊(duì)等候，等其他線程執(zhí)行完畢吴攒，再從隊(duì)列中取出任務(wù)來執(zhí)行洼怔。

?主要特點(diǎn)是：線程復(fù)用镣隶、控制最大并發(fā)數(shù)轻猖、管理線程咙边。
??1.降低資源消耗败许。通過重復(fù)利用已創(chuàng)建的線程降低線程創(chuàng)建和銷毀造成的消耗市殷。
??2.提高響應(yīng)速度。當(dāng)任務(wù)到達(dá)時(shí)音羞，任務(wù)可以不需要等到線程創(chuàng)建就能立即執(zhí)行黄选。
??3.提高線程的可管理性办陷。線程是稀缺資源，如果無限制的創(chuàng)建制圈，不僅會(huì)消耗系統(tǒng)資源鲸鹦，還會(huì)降低系統(tǒng)的穩(wěn)定性馋嗜，使用線程池可以進(jìn)行統(tǒng)一的分配甘磨，調(diào)優(yōu)和監(jiān)控济舆。

idea_ThreadPoolExecutor繼承圖.png

ThreadPoolExecutor的構(gòu)造方法

ThreadPoolExecutor的構(gòu)造方法.png

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

??1. int corePoolSize：線程池中的常駐核心線程數(shù)
???核心線程：線程池新建線程的時(shí)候齐邦，如果當(dāng)前線程總數(shù)小于corePoolSize侄旬，則新建的是核心線程宣羊，如果超過corePoolSize仇冯，則新建的是非核心線程核心線程默認(rèn)情況下會(huì)一直存活在線程池中苛坚，即使這個(gè)核心線程是閑置狀態(tài)泼舱。
???如果指定ThreadPoolExecutor的allowCoreThreadTimeOut這個(gè)屬性為true，那么核心線程如果為閑置狀態(tài)冒掌，超過一定時(shí)間(時(shí)長下面參數(shù)決定)股毫，就會(huì)被銷毀掉铃诬。
??2.int maximumPoolSize：線程池能夠容納同時(shí)執(zhí)行的最大線程數(shù)
???maximumPoolSize此值必須大于等于1.
???maximumPoolSize = corePoolSize + 非核心線程數(shù)（可緩沖的線程數(shù)）。
??3.long keepAliveTime：多余空閑線程的存活時(shí)間
???當(dāng)前線程池?cái)?shù)量超過corePoolSize時(shí)吩坝，當(dāng)空閑時(shí)間達(dá)到keepAliveTime值時(shí)钉寝，多余空閑線程會(huì)被銷毀直到只剩下corePoolSize個(gè)線程為止。
???默認(rèn)情況下,只有當(dāng)線程池中的線程數(shù)大于corePoolSize時(shí)keepAliveTime才會(huì)起作用腥沽，直到線程池中的線程數(shù)不大于corePoolSize师溅。
??4.TimeUnit unit：keepAliveTime的單位
??5.BlockingQueue workQueue：被提交但尚未被執(zhí)行的任務(wù)隊(duì)列
???當(dāng)所有的核心線程都在工作時(shí)墓臭，新添加的任務(wù)會(huì)被添加到這個(gè)隊(duì)列中等待處理，如果隊(duì)列滿了嗡载，則新建非核心線程執(zhí)行任務(wù)鼻疮。
??6.ThreadFactory threadFactory：創(chuàng)建線程的方式判沟。
???用于創(chuàng)建線程，一般用默認(rèn)的即可琉闪。
??7.RejectedExecutionHandler handler：拒絕策略
???當(dāng)提交任務(wù)數(shù)超過maxmumPoolSize+workQueue之和時(shí)斯入，任務(wù)會(huì)交給RejectedExecutionHandler來處理刻两。

jdk1.5提供的四種拒絕策略 ：

?1.AbortPolicy（默認(rèn)）：直接拋出RejectedExecutionException異常阻止系統(tǒng)正常運(yùn)行滋迈。
?2.CallerRunsPolicy：“調(diào)用者運(yùn)行”一種調(diào)節(jié)機(jī)制饼灿，該策略既不會(huì)拋棄任務(wù)，也不會(huì)拋出異常硕旗，而是將某些任務(wù)回退到調(diào)用者漆枚，從而降低新任務(wù)的流量墙基。
?3.DiscardOldestPolicy：拋棄隊(duì)列中等待最久的任務(wù)，然后把當(dāng)前任務(wù)加入隊(duì)列中嘗試再次提交當(dāng)前任務(wù)初茶。
?4.DiscardPolicy：直接丟棄任務(wù)恼布，不予任何處理也不拋出異常折汞。如果允許任務(wù)丟失损同，這是最好的一種方案膏燃。
?以上內(nèi)置拒絕策略均實(shí)現(xiàn)了RejectedExecutionHandler接口

線程池的處理流程

3. 線程池的處理流程 .png

?線程池判斷核心線程池里是的線程是否都在執(zhí)行任務(wù)，如果不是（正在執(zhí)行的線程數(shù) 小于 corePoolSize），則創(chuàng)建一個(gè)新的工作線程來執(zhí)行任務(wù)霍比。如果核心線程池里的線程都在執(zhí)行任務(wù)（正在執(zhí)行的線程數(shù) 大于 corePoolSize）悠瞬，則進(jìn)入下一個(gè)流程
?線程池判斷工作隊(duì)列是否已滿浅妆。如果工作隊(duì)列沒有滿凌外，則將新提交的任務(wù)儲(chǔ)存在這個(gè)工作隊(duì)列里。如果工作隊(duì)列滿了疮薇，則進(jìn)入下一個(gè)流程按咒。
?線程池判斷其內(nèi)部線程是否都處于工作狀態(tài)励七。如果沒有正在（運(yùn)行的線程數(shù)量小于maximumPoolSize），則創(chuàng)建一個(gè)新的工作線程來執(zhí)行任務(wù)剿另。如果已滿了（運(yùn)行的線程數(shù)量 大于 maximumPoolSize）雨女，則交給飽和策略來處理這個(gè)任務(wù)馏臭。
?當(dāng)一個(gè)線程完成任務(wù)時(shí)括儒，它會(huì)從隊(duì)列中取下一個(gè)任務(wù)來執(zhí)行。
?當(dāng)一個(gè)線程無事可做超過一定的時(shí)間（keepAlilveTime）時(shí)固逗，線程池會(huì)判斷：如果當(dāng)前運(yùn)行的線程數(shù)大于corePoolSize烫罩，那么這個(gè)線程就被停掉贝攒。線程池的所有任務(wù)完成后最終會(huì)收縮到corePoolSize的大小。

線程池執(zhí)行時(shí)的四種情況

image.png

??如果當(dāng)前運(yùn)行的線程少于corePoolSize长捧，則創(chuàng)建新線程來執(zhí)行任務(wù)
??如果運(yùn)行的線程等于或多于corePoolSize ,則將任務(wù)加入BlockingQueue
??如果無法將任務(wù)加入BlockingQueue(隊(duì)列已滿)，則創(chuàng)建新的線程來處理任務(wù)
??如果創(chuàng)建新線程將使當(dāng)前運(yùn)行的線程超出maxiumPoolSize肌割，任務(wù)將被拒絕把敞，并調(diào)用RejectedExecutionHandler.rejectedExecution()方法奋早。

Java提供的線程池

?Java在Executors工具類中提供了5種線程池
??1. SingleThreadExecutor 單一線程池
???它只會(huì)創(chuàng)建一條工作線程處理任務(wù)愤炸；
???采用的阻塞隊(duì)列為LinkedBlockingQueue规个；

??2.FixedThreadPool 定長線程池

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());

???它是一種固定大小的線程池；
???corePoolSize和maximunPoolSize都為用戶設(shè)定的線程數(shù)量nThreads墅拭；
???keepAliveTime為0帜矾，意味著一旦有多余的空閑線程，就會(huì)被立即停止掉掸宛；但這里keepAliveTime無效；
???阻塞隊(duì)列采用了LinkedBlockingQueue饰序，它是一個(gè)無界隊(duì)列求豫；
???由于阻塞隊(duì)列是一個(gè)無界隊(duì)列蝠嘉，因此永遠(yuǎn)不可能拒絕任務(wù)；
???由于采用了無界隊(duì)列杜恰，實(shí)際線程數(shù)量將永遠(yuǎn)維持在nThreads，因此maximumPoolSize和keepAliveTime將無效烙荷。
??3. CachedThreadPool 可緩存線程池

public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

???它是一個(gè)可以無限擴(kuò)大的線程池；
???它比較適合處理執(zhí)行時(shí)間比較小的任務(wù)昼伴；
corePoolSize為0，maximumPoolSize為無限大女蜈，意味著線程數(shù)量可以無限大逸寓；
???keepAliveTime為60S竹伸，意味著線程空閑時(shí)間超過60S就會(huì)被殺死勋篓；
???采用SynchronousQueue裝等待的任務(wù)，這個(gè)阻塞隊(duì)列沒有存儲(chǔ)空間拜银，這意味著只要有請(qǐng)求到來盐股，就必須要找到一條工作線程處理他疯汁，如果當(dāng)前沒有空閑的線程谤碳，那么就會(huì)再創(chuàng)建一條新的線程蜒简。
??4. ScheduledThreadPool 可調(diào)度的線程池
???它用來處理延時(shí)任務(wù)或定時(shí)任務(wù)搓茬。
???它接收SchduledFutureTask類型的任務(wù)卷仑，有兩種提交任務(wù)的方式：
????scheduledAtFixedRate
????scheduledWithFixedDelay
???SchduledFutureTask接收的參數(shù)：
????time：任務(wù)開始的時(shí)間
????sequenceNumber：任務(wù)的序號(hào)
????period：任務(wù)執(zhí)行的時(shí)間間隔
???它采用DelayQueue存儲(chǔ)等待的任務(wù)
DelayQueue內(nèi)部封裝了一個(gè)PriorityQueue，它會(huì)根據(jù)time的先后時(shí)間排序窜锯，若time相同則根據(jù)sequenceNumber排序锚扎；
???DelayQueue也是一個(gè)無界隊(duì)列工秩；
???工作線程的執(zhí)行過程：
????工作線程會(huì)從DelayQueue取已經(jīng)到期的任務(wù)去執(zhí)行；
執(zhí)行結(jié)束后重新設(shè)置任務(wù)的到期時(shí)間螟碎，再次放回DelayQueue
??5. newWorkStealingPool Java8新增，使用可用的處理器作為它的并行級(jí)別
???待補(bǔ)充

生產(chǎn)上應(yīng)該使用哪種線程池

?在阿里巴巴Java開發(fā)手冊并發(fā)處理章節(jié)中嚴(yán)禁使用Java提供的線程池酥郭，所以生產(chǎn)上只能使用自定義的線程池不从。

【強(qiáng)制】線程資源必須通過線程池提供歹袁，不允許在應(yīng)用中自行顯式創(chuàng)建線程条舔。 說明：使用線程池的好處是減少在創(chuàng)建和銷毀線程上所消耗的時(shí)間以及系統(tǒng)資源的開銷孟抗，解決資源不足的問題。如果不使用線程池帆喇，有可能造成系統(tǒng)創(chuàng)建大量同類線程而導(dǎo)致消耗完內(nèi)存或者“過度切換”的問題坯钦。

【強(qiáng)制】線程池不允許使用Executors去創(chuàng)建婉刀，而是通過ThreadPoolExecutor的方式，這樣的處理方式讓寫的同學(xué)更加明確線程池的運(yùn)行規(guī)則律秃，規(guī)避資源耗盡的風(fēng)險(xiǎn)棒动。說明：Executors返回的線程池對(duì)象的弊端如下：
?1）FixedThreadPool和SingleThreadPool:允許的請(qǐng)求隊(duì)列長度為Integer.MAX_VALUE船惨，可能會(huì)堆積大量的請(qǐng)求，從而導(dǎo)致OOM怜浅。
?2）CachedThreadPool和ScheduledThreadPool:允許的創(chuàng)建線程數(shù)量為Integer.MAX_VALUE海雪，可能會(huì)創(chuàng)建大量的線程险掀，從而導(dǎo)致OOM樟氢。

向線程池提交任務(wù)

?1.void execute(Runnable command)
??用于提交不需要返回值的任務(wù)，所以無法判斷任務(wù)是否被線程池執(zhí)行成功

    ExecutorService executorService = Executors.newFixedThreadPool(5);
    executorService.execute(() -> System.out.println(Thread.currentThread().getName())); 

?2.<T> Future<T> submit(Callable<T> task)
??用于提交需要返回值的任務(wù)

    Future<Integer> future = executorService.submit(() -> (int) Math.random());
    Integer i = future.get();
    System.out.println(i);

關(guān)閉線程池

?ThreadPoolExecutor提供了兩個(gè)方法碴开，用于線程池的關(guān)閉，分別是shutdown()和shutdownNow()巴碗，它們的原理是遍歷線程池中的工作線程，然后逐個(gè)調(diào)用線程的interrupt方法來中斷線程逸爵，但這兩種方式對(duì)于正在執(zhí)行的線程處理方式不同痊银。
?1.shutdown()
??僅停止阻塞隊(duì)列中等待的線程，那些正在執(zhí)行的線程就會(huì)讓他們執(zhí)行結(jié)束。
?2.shutdownNow()
??不僅會(huì)停止阻塞隊(duì)列中的線程冈闭，而且會(huì)停止正在執(zhí)行的線程遇八。

合理配置線程池

?CPU 密集型
??CPU 密集的意思是該任務(wù)需要大量的運(yùn)算货矮，而沒有阻塞囚玫，CPU 一直全速運(yùn)行抓督。
??CPU 密集型任務(wù)盡可能的少的線程數(shù)量，一般為 CPU 核數(shù) + 1 個(gè)線程的線程池束亏。
?IO 密集型
??由于 IO 密集型任務(wù)線程并不是一直在執(zhí)行任務(wù)铃在，可以多分配一點(diǎn)線程數(shù)，如 CPU * 2 碍遍。
??也可以使用公式：CPU 核數(shù) / (1 - 阻塞系數(shù))涌穆；其中阻塞系數(shù)在 0.8 ～ 0.9 之間。