【重學Java】多執行緒進階（執行緒池、原子性、併發工具類）

gonghr發表於2021-07-16

執行緒池

執行緒狀態介紹

當執行緒被建立並啟動以後，它既不是一啟動就進入了執行狀態，也不是一直處於執行狀態。執行緒物件在不同的時期有不同的狀態。那麼Java中的執行緒存在哪幾種狀態呢？Java中的執行緒

狀態被定義在了java.lang.Thread.State列舉類中，State列舉類的原始碼如下：

public class Thread {
    
    public enum State {
    
        /* 新建 */
        NEW , 

        /* 可執行狀態 */
        RUNNABLE , 

        /* 阻塞狀態 */
        BLOCKED , 

        /* 無限等待狀態 */
        WAITING , 

        /* 計時等待 */
        TIMED_WAITING , 

        /* 終止 */
        TERMINATED;
    
	}
    
    // 獲取當前執行緒的狀態
    public State getState() {
        return jdk.internal.misc.VM.toThreadState(threadStatus);
    }
    
}

通過原始碼我們可以看到Java中的執行緒存在6種狀態，每種執行緒狀態的含義如下

執行緒狀態	具體含義
NEW	一個尚未啟動的執行緒的狀態。也稱之為初始狀態、開始狀態。執行緒剛被建立，但是並未啟動。還沒呼叫start方法。MyThread t = new MyThread()只有執行緒象，沒有執行緒特徵。
RUNNABLE	當我們呼叫執行緒物件的start方法，那麼此時執行緒物件進入了RUNNABLE狀態。那麼此時才是真正的在JVM程式中建立了一個執行緒，執行緒一經啟動並不是立即得到執行，執行緒的執行與否要聽令與CPU的排程，那麼我們把這個中間狀態稱之為可執行狀態(RUNNABLE)也就是說它具備執行的資格，但是並沒有真正的執行起來而是在等待CPU的度。
BLOCKED	當一個執行緒試圖獲取一個物件鎖，而該物件鎖被其他的執行緒持有，則該執行緒進入Blocked狀態；當該執行緒持有鎖時，該執行緒將變成Runnable狀態。
WAITING	一個正在等待的執行緒的狀態。也稱之為等待狀態。造成執行緒等待的原因有兩種，分別是呼叫Object.wait()、join()方法。處於等待狀態的執行緒，正在等待其他執行緒去執行一個特定的操作。例如：因為wait()而等待的執行緒正在等待另一個執行緒去呼叫notify()或notifyAll()；一個因為join()而等待的執行緒正在等待另一個執行緒結束。
TIMED_WAITING	一個在限定時間內等待的執行緒的狀態。也稱之為限時等待狀態。造成執行緒限時等待狀態的原因有三種，分別是：Thread.sleep(long)，Object.wait(long)、join(long)。
TERMINATED	一個完全執行完成的執行緒的狀態。也稱之為終止狀態、結束狀態

各個狀態的轉換，如下圖所示：

執行緒池-基本原理

概述 :

提到池，大家應該能想到的就是水池。水池就是一個容器，在該容器中儲存了很多的水。那麼什麼是執行緒池呢？執行緒池也是可以看做成一個池子，在該池子中儲存很多個執行緒。

執行緒池存在的意義：

系統建立一個執行緒的成本是比較高的，因為它涉及到與作業系統互動，當程式中需要建立大量生存期很短暫的執行緒時，頻繁的建立和銷燬執行緒對系統的資源消耗有可能大於業務處理是對系統資源的消耗，這樣就有點"捨本逐末"了。針對這一種情況，為了提高效能，我們就可以採用執行緒池。執行緒池在啟動的時，會建立大量空閒執行緒，當我們向執行緒池提交任務的時，執行緒池就會啟動一個執行緒來執行該任務。等待任務執行完畢以後，執行緒並不會死亡，而是再次返回到執行緒池中稱為空閒狀態。等待下一次任務的執行。

執行緒池的設計思路 :

準備一個任務容器
一次性啟動多個(2個)消費者執行緒
剛開始任務容器是空的，所以執行緒都在wait
直到一個外部執行緒向這個任務容器中扔了一個"任務"，就會有一個消費者執行緒被喚醒
這個消費者執行緒取出"任務"，並且執行這個任務，執行完畢後，繼續等待下一次任務的到來

執行緒池-Executors預設執行緒池

概述 : JDK對執行緒池也進行了相關的實現，在真實企業開發中我們也很少去自定義執行緒池，而是使用JDK中自帶的執行緒池。

我們可以使用Executors中所提供的靜態方法來建立執行緒池

方法名	說明
static ExecutorService newCachedThreadPool()	建立一個預設的執行緒池
static ExecutorService newFixedThreadPool(int nThreads)	建立一個指定最多執行緒數量的執行緒池

程式碼實現 :


//static ExecutorService newCachedThreadPool()   建立一個預設的執行緒池
//static ExecutorService newFixedThreadPool(int nThreads)	    建立一個指定最多執行緒數量的執行緒池

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

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

        //1,建立一個預設的執行緒池物件.池子中預設是空的.預設最多可以容納int型別的最大值.
        ExecutorService executorService = Executors.newCachedThreadPool();
        //Executors --- 可以幫助我們建立執行緒池物件
        //ExecutorService --- 可以幫助我們控制執行緒池

        executorService.submit(()->{
            System.out.println(Thread.currentThread().getName() + "在執行了");
        });

        //Thread.sleep(2000);

        executorService.submit(()->{
            System.out.println(Thread.currentThread().getName() + "在執行了");
        });

        executorService.shutdown();
    }
}

執行緒池-Executors建立指定上限的執行緒池

使用Executors中所提供的靜態方法來建立執行緒池

方法名	說明
static ExecutorService newFixedThreadPool(int nThreads)	建立一個指定最多執行緒數量的執行緒池

程式碼實現 :


//static ExecutorService newFixedThreadPool(int nThreads)
//建立一個指定最多執行緒數量的執行緒池

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

public class MyThreadPoolDemo2 {
    public static void main(String[] args) {
        //引數不是初始值而是最大值
        ExecutorService executorService = Executors.newFixedThreadPool(10);

        ThreadPoolExecutor pool = (ThreadPoolExecutor) executorService;
        System.out.println(pool.getPoolSize());//0

        executorService.submit(()->{
            System.out.println(Thread.currentThread().getName() + "在執行了");
        });

        executorService.submit(()->{
            System.out.println(Thread.currentThread().getName() + "在執行了");
        });

        System.out.println(pool.getPoolSize());//2
//        executorService.shutdown();
    }
}

執行緒池-ThreadPoolExecutor

建立執行緒池物件 :

ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(核心執行緒數量,最大執行緒數量,空閒執行緒最大存活時間,任務佇列,建立執行緒工廠,任務的拒絕策略);

程式碼實現 :


import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class MyThreadPoolDemo3 {
//    引數一：核心執行緒數量
//    引數二：最大執行緒數
//    引數三：空閒執行緒最大存活時間
//    引數四：時間單位    ---TimeUnit
//    引數五：任務佇列    ---讓任務在佇列裡等著，等有執行緒空閒了，再從佇列中獲取任務並執行
//    引數六：建立執行緒工廠    ---按照預設方式建立執行緒物件
//    引數七：任務的拒絕策略    ---什麼時候拒絕任務：提交的任務 > 池子中最大執行緒數 + 佇列容量
    public static void main(String[] args) {
        ThreadPoolExecutor pool = new ThreadPoolExecutor(2,5,2,TimeUnit.SECONDS,new ArrayBlockingQueue<>(10), Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());
        pool.submit(new MyRunnable());
        pool.submit(new MyRunnable());

        pool.shutdown();
    }
}

執行緒池-引數詳解

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)
    
corePoolSize：   核心執行緒的最大值，不能小於0
maximumPoolSize：最大執行緒數，不能小於等於0，maximumPoolSize >= corePoolSize
keepAliveTime：  空閒執行緒最大存活時間,不能小於0
unit：           時間單位
workQueue：      任務佇列，不能為null
threadFactory：  建立執行緒工廠,不能為null      
handler：        任務的拒絕策略,不能為null

執行緒池-非預設任務拒絕策略

RejectedExecutionHandler是jdk提供的一個任務拒絕策略介面，它下面存在4個子類。

ThreadPoolExecutor.AbortPolicy: 		    丟棄任務並丟擲RejectedExecutionException異常。是預設的策略。
ThreadPoolExecutor.DiscardPolicy： 		   丟棄任務，但是不丟擲異常 這是不推薦的做法。
ThreadPoolExecutor.DiscardOldestPolicy：    拋棄佇列中等待最久的任務 然後把當前任務加入佇列中。
ThreadPoolExecutor.CallerRunsPolicy:        呼叫任務的run()方法繞過執行緒池直接執行。

注：明確執行緒池對多可執行的任務數 = 佇列容量 + 最大執行緒數

案例演示1：演示ThreadPoolExecutor.AbortPolicy任務處理策略

public class ThreadPoolExecutorDemo01 {

    public static void main(String[] args) {

        /**
         * 核心執行緒數量為1 ， 最大執行緒池數量為3, 任務容器的容量為1 ,空閒執行緒的最大存在時間為20s
         */
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1 , 3 , 20 , TimeUnit.SECONDS ,
                new ArrayBlockingQueue<>(1) , Executors.defaultThreadFactory() , new ThreadPoolExecutor.AbortPolicy()) ;

        // 提交5個任務，而該執行緒池最多可以處理4個任務，當我們使用AbortPolicy這個任務處理策略的時候，就會丟擲異常
        for(int x = 0 ; x < 5 ; x++) {
            threadPoolExecutor.submit(() -> {
                System.out.println(Thread.currentThread().getName() + "---->> 執行了任務");
            });
        }
    }
}

控制檯輸出結果

pool-1-thread-1---->> 執行了任務
pool-1-thread-3---->> 執行了任務
pool-1-thread-2---->> 執行了任務
pool-1-thread-3---->> 執行了任務

控制檯報錯，僅僅執行了4個任務，有一個任務被丟棄了

案例演示2：演示ThreadPoolExecutor.DiscardPolicy任務處理策略

public class ThreadPoolExecutorDemo02 {
    public static void main(String[] args) {
        /**
         * 核心執行緒數量為1 ， 最大執行緒池數量為3, 任務容器的容量為1 ,空閒執行緒的最大存在時間為20s
         */
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1 , 3 , 20 , TimeUnit.SECONDS ,
                new ArrayBlockingQueue<>(1) , Executors.defaultThreadFactory() , new ThreadPoolExecutor.DiscardPolicy()) ;

        // 提交5個任務，而該執行緒池最多可以處理4個任務，當我們使用DiscardPolicy這個任務處理策略的時候，控制檯不會報錯
        for(int x = 0 ; x < 5 ; x++) {
            threadPoolExecutor.submit(() -> {
                System.out.println(Thread.currentThread().getName() + "---->> 執行了任務");
            });
        }
    }
}

控制檯輸出結果

pool-1-thread-1---->> 執行了任務
pool-1-thread-1---->> 執行了任務
pool-1-thread-3---->> 執行了任務
pool-1-thread-2---->> 執行了任務

控制檯沒有報錯，僅僅執行了4個任務，有一個任務被丟棄了

案例演示3：演示ThreadPoolExecutor.DiscardOldestPolicy任務處理策略

public class ThreadPoolExecutorDemo02 {
    public static void main(String[] args) {
        /**
         * 核心執行緒數量為1 ， 最大執行緒池數量為3, 任務容器的容量為1 ,空閒執行緒的最大存在時間為20s
         */
        ThreadPoolExecutor threadPoolExecutor;
        threadPoolExecutor = new ThreadPoolExecutor(1 , 3 , 20 , TimeUnit.SECONDS ,
                new ArrayBlockingQueue<>(1) , Executors.defaultThreadFactory() , new ThreadPoolExecutor.DiscardOldestPolicy());
        // 提交5個任務
        for(int x = 0 ; x < 5 ; x++) {
            // 定義一個變數，來指定指定當前執行的任務;這個變數需要被final修飾
            final int y = x ;
            threadPoolExecutor.submit(() -> {
                System.out.println(Thread.currentThread().getName() + "---->> 執行了任務" + y);
            });     
        }
    }
}

控制檯輸出結果

pool-1-thread-2---->> 執行了任務2
pool-1-thread-1---->> 執行了任務0
pool-1-thread-3---->> 執行了任務3
pool-1-thread-1---->> 執行了任務4

由於任務1線上程池中等待時間最長，因此任務1被丟棄。

案例演示4：演示ThreadPoolExecutor.CallerRunsPolicy任務處理策略

public class ThreadPoolExecutorDemo04 {
    public static void main(String[] args) {

        /**
         * 核心執行緒數量為1 ， 最大執行緒池數量為3, 任務容器的容量為1 ,空閒執行緒的最大存在時間為20s
         */
        ThreadPoolExecutor threadPoolExecutor;
        threadPoolExecutor = new ThreadPoolExecutor(1 , 3 , 20 , TimeUnit.SECONDS ,
                new ArrayBlockingQueue<>(1) , Executors.defaultThreadFactory() , new ThreadPoolExecutor.CallerRunsPolicy());

        // 提交5個任務
        for(int x = 0 ; x < 5 ; x++) {
            threadPoolExecutor.submit(() -> {
                System.out.println(Thread.currentThread().getName() + "---->> 執行了任務");
            });
        }
    }
}

控制檯輸出結果

pool-1-thread-1---->> 執行了任務
pool-1-thread-3---->> 執行了任務
pool-1-thread-2---->> 執行了任務
pool-1-thread-1---->> 執行了任務
main---->> 執行了任務

通過控制檯的輸出，我們可以看到次策略沒有通過執行緒池中的執行緒執行任務，而是直接呼叫任務的run()方法繞過執行緒池直接執行。

阿里巴巴關於執行緒池的規範

阿里巴巴Java開發手冊
【強制】建立執行緒或執行緒池時請指定有意義的執行緒名稱，方便出錯時回溯。
【強制】執行緒資源必須通過執行緒池提供，不允許在應用中自行顯式建立執行緒。
【強制】執行緒池不允許使用 Executors 去建立，而是通過 ThreadPoolExecutor 的方式，這樣的處理方式讓寫的同學更加明確執行緒池的執行規則，規避資源耗盡的風險。
禁止直接使用Executors建立執行緒池原因：
FixedThreadPool 和 SingleThreadPool:
允許的請求佇列長度為 Integer.MAX_VALUE，可能會堆積大量的請求，從而導致 OOM（Out Of Memory）。
CachedThreadPool 和 ScheduledThreadPool:
允許的建立執行緒數量為 Integer.MAX_VALUE，可能會建立大量的執行緒，從而導致 OOM。

原子性

volatile-問題

程式碼分析 :


public class Demo {
    public static void main(String[] args) {
        MyThread1 t1 = new MyThread1();
        t1.setName("小路同學");
        t1.start();

        MyThread2 t2 = new MyThread2();
        t2.setName("小皮同學");
        t2.start();
    }
}


public class Money {
    public static int money = 100000;
}


public class MyThread1 extends  Thread {
    @Override
    public void run() {
        while(Money.money == 100000){

        }

        System.out.println("結婚基金已經不是十萬了");
    }
}


public class MyThread2 extends Thread {
    @Override
    public void run() {
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        Money.money = 90000;
    }
}

程式問題 : 女孩雖然知道結婚基金是十萬，但是當基金的餘額發生變化的時候，女孩無法知道最新的餘額。

volatile解決

以上案例出現的問題 :

當A執行緒修改了共享資料時，B執行緒沒有及時獲取到最新的值，如果還在使用原先的值，就會出現問題

1，堆記憶體是唯一的，每一個執行緒都有自己的執行緒棧。

2 ，每一個執行緒在使用堆裡面變數的時候，都會先拷貝一份到變數的副本中。

3 ，線上程中，每一次使用是從變數的副本中獲取的。

Volatile關鍵字 : 強制執行緒每次在使用的時候，都會看一下共享區域最新的值

程式碼實現 : 使用volatile關鍵字解決


public class Demo {
    public static void main(String[] args) {
        MyThread1 t1 = new MyThread1();
        t1.setName("小路同學");
        t1.start();

        MyThread2 t2 = new MyThread2();
        t2.setName("小皮同學");
        t2.start();
    }
}


public class Money {
    public static volatile int money = 100000;
}


public class MyThread1 extends  Thread {
    @Override
    public void run() {
        while(Money.money == 100000){

        }

        System.out.println("結婚基金已經不是十萬了");
    }
}


public class MyThread2 extends Thread {
    @Override
    public void run() {
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        Money.money = 90000;
    }
}

synchronized解決

synchronized解決 :

1 ，執行緒獲得鎖

2 ，清空變數副本

3 ，拷貝共享變數最新的值到變數副本中

4 ，執行程式碼

5 ，將修改後變數副本中的值賦值給共享資料

6 ，釋放鎖

程式碼實現 :


public class Demo {
    public static void main(String[] args) {
        MyThread1 t1 = new MyThread1();
        t1.setName("小路同學");
        t1.start();

        MyThread2 t2 = new MyThread2();
        t2.setName("小皮同學");
        t2.start();
    }
}


public class Money {
    public static Object lock = new Object();
    public static volatile int money = 100000;
}


public class MyThread1 extends  Thread {
    @Override
    public void run() {
        while(true){
            synchronized (Money.lock){
                if(Money.money != 100000){
                    System.out.println("結婚基金已經不是十萬了");
                    break;
                }
            }
        }
    }
}


public class MyThread2 extends Thread {
    @Override
    public void run() {
        synchronized (Money.lock) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            Money.money = 90000;
        }
    }
}

原子性

概述 : 所謂的原子性是指在一次操作或者多次操作中，要麼所有的操作全部都得到了執行並且不會受到任何因素的干擾而中斷，要麼所有的操作都不執行，多個操作是一個不可以分割的整體。

程式碼實現 :


public class AtomDemo {
    public static void main(String[] args) {
        MyAtomThread atom = new MyAtomThread();

        for (int i = 0; i < 100; i++) {
            new Thread(atom).start();
        }
    }
}
class MyAtomThread implements Runnable {
    private volatile int count = 0; //送冰淇淋的數量

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            //1,從共享資料中讀取資料到本執行緒棧中.
            //2,修改本執行緒棧中變數副本的值
            //3,會把本執行緒棧中變數副本的值賦值給共享資料.
            count++;
            System.out.println("已經送了" + count + "個冰淇淋");
        }
    }
}

程式碼總結 : count++ 不是一個原子性操作, 他在執行的過程中,有可能被其他執行緒打斷

volatile關鍵字不能保證原子性

解決方案 : 我們可以給count++操作新增鎖，那麼count++操作就是臨界區中的程式碼，臨界區中的程式碼一次只能被一個執行緒去執行，所以count++就變成了原子操作。


public class AtomDemo {
    public static void main(String[] args) {
        MyAtomThread atom = new MyAtomThread();

        for (int i = 0; i < 100; i++) {
            new Thread(atom).start();
        }
    }
}
class MyAtomThread implements Runnable {
    private volatile int count = 0; //送冰淇淋的數量
    private Object lock = new Object();

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            //1,從共享資料中讀取資料到本執行緒棧中.
            //2,修改本執行緒棧中變數副本的值
            //3,會把本執行緒棧中變數副本的值賦值給共享資料.
            synchronized (lock) {
                count++;
                System.out.println("已經送了" + count + "個冰淇淋");
            }
        }
    }
}

volatile 只能保證每次使用共享資料時是最新值，但不能保證原子性

原子性_AtomicInteger

概述：java從JDK1.5開始提供了java.util.concurrent.atomic包(簡稱Atomic包)，這個包中的原子操作類提供了一種用法簡單，效能高效，執行緒安全地更新一個變數的方式。因為變

量的型別有很多種，所以在Atomic包裡一共提供了13個類，屬於4種型別的原子更新方式，分別是原子更新基本型別、原子更新陣列、原子更新引用和原子更新屬性(欄位)。本次我們只講解

使用原子的方式更新基本型別，使用原子的方式更新基本型別Atomic包提供了以下3個類：

AtomicBoolean：原子更新布林型別

AtomicInteger：原子更新整型

AtomicLong：原子更新長整型

以上3個類提供的方法幾乎一模一樣，所以本節僅以AtomicInteger為例進行講解，AtomicInteger的常用方法如下：

public AtomicInteger()：	   			    初始化一個預設值為0的原子型Integer
public AtomicInteger(int initialValue)：  初始化一個指定值的原子型Integer

int get():   			 				獲取值
int getAndIncrement():      			 以原子方式將當前值加1，注意，這裡返回的是自增前的值。
int incrementAndGet():     				 以原子方式將當前值加1，注意，這裡返回的是自增後的值。
int addAndGet(int data):				 以原子方式將輸入的數值與例項中的值（AtomicInteger裡的value）相加，並返回結果。
int getAndSet(int value):   			 以原子方式設定為newValue的值，並返回舊值。

程式碼實現 :



import java.util.concurrent.atomic.AtomicInteger;

public class MyAtomIntergerDemo1 {
//    public AtomicInteger()：	               初始化一個預設值為0的原子型Integer
//    public AtomicInteger(int initialValue)： 初始化一個指定值的原子型Integer
    public static void main(String[] args) {
        AtomicInteger ac = new AtomicInteger();
        System.out.println(ac);

        AtomicInteger ac2 = new AtomicInteger(10);
        System.out.println(ac2);
    }

}



import java.lang.reflect.Field;
import java.util.concurrent.atomic.AtomicInteger;

public class MyAtomIntergerDemo2 {
//    int get():   		 		獲取值
//    int getAndIncrement():     以原子方式將當前值加1，注意，這裡返回的是自增前的值。
//    int incrementAndGet():     以原子方式將當前值加1，注意，這裡返回的是自增後的值。
//    int addAndGet(int data):	 以原子方式將引數與物件中的值相加，並返回結果。
//    int getAndSet(int value):  以原子方式設定為newValue的值，並返回舊值。
    public static void main(String[] args) {
//        AtomicInteger ac1 = new AtomicInteger(10);
//        System.out.println(ac1.get());

//        AtomicInteger ac2 = new AtomicInteger(10);
//        int andIncrement = ac2.getAndIncrement();
//        System.out.println(andIncrement);
//        System.out.println(ac2.get());

//        AtomicInteger ac3 = new AtomicInteger(10);
//        int i = ac3.incrementAndGet();
//        System.out.println(i);//自增後的值
//        System.out.println(ac3.get());

//        AtomicInteger ac4 = new AtomicInteger(10);
//        int i = ac4.addAndGet(20);
//        System.out.println(i);
//        System.out.println(ac4.get());

        AtomicInteger ac5 = new AtomicInteger(100);
        int andSet = ac5.getAndSet(20);
        System.out.println(andSet);
        System.out.println(ac5.get());
    }
}

AtomicInteger-記憶體解析

AtomicInteger原理 : 自旋鎖 + CAS 演算法

CAS演算法：

有3個運算元（記憶體值V，舊的預期值A，要修改的值B）

當舊的預期值A == 記憶體值此時修改成功，將V改為B

當舊的預期值A！=記憶體值此時修改失敗，不做任何操作

並重新獲取現在的最新值（這個重新獲取的動作就是自旋）

AtomicInteger-原始碼解析

程式碼實現 :


public class AtomDemo {
    public static void main(String[] args) {
        MyAtomThread atom = new MyAtomThread();

        for (int i = 0; i < 100; i++) {
            new Thread(atom).start();
        }
    }
}


import java.util.concurrent.atomic.AtomicInteger;

public class MyAtomThread implements Runnable {
    //private volatile int count = 0; //送冰淇淋的數量
    //private Object lock = new Object();
    AtomicInteger ac = new AtomicInteger(0);

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            //1,從共享資料中讀取資料到本執行緒棧中.
            //2,修改本執行緒棧中變數副本的值
            //3,會把本執行緒棧中變數副本的值賦值給共享資料.
            //synchronized (lock) {
//                count++;
//                ac++;
            int count = ac.incrementAndGet();
            System.out.println("已經送了" + count + "個冰淇淋");
           // }
        }
    }
}

原始碼解析 :

//先自增，然後獲取自增後的結果
public final int incrementAndGet() {
        //+ 1 自增後的結果
        //this 就表示當前的atomicInteger（值）
        //1    自增一次
        return U.getAndAddInt(this, VALUE, 1) + 1;
}

public final int getAndAddInt(Object o, long offset, int delta) {
        //v 舊值
        int v;
        //自旋的過程
        do {
            //不斷的獲取舊值
            v = getIntVolatile(o, offset);
            //如果這個方法的返回值為false，那麼繼續自旋
            //如果這個方法的返回值為true，那麼自旋結束
            //o 表示的就是記憶體值
            //v 舊值
            //v + delta 修改後的值
        } while (!weakCompareAndSetInt(o, offset, v, v + delta));
            //作用：比較記憶體中的值，舊值是否相等，如果相等就把修改後的值寫到記憶體中，返回true。表示修改成功。
            //                                 如果不相等，無法把修改後的值寫到記憶體中，返回false。表示修改失敗。
            //如果修改失敗，那麼繼續自旋。
        return v;
}

悲觀鎖和樂觀鎖

synchronized和CAS的區別 :

相同點：在多執行緒情況下，都可以保證共享資料的安全性。

不同點：synchronized總是從最壞的角度出發，認為每次獲取資料的時候，別人都有可能修改。所以在每次操作共享資料之前，都會上鎖。（悲觀鎖）

cas是從樂觀的角度出發，假設每次獲取資料別人都不會修改，所以不會上鎖。只不過在修改共享資料的時候，會檢查一下，別人有沒有修改過這個資料。

如果別人修改過，那麼我再次獲取現在最新的值。

如果別人沒有修改過，那麼我現在直接修改共享資料的值.(樂觀鎖）

併發工具類

併發工具類-Hashtable

Hashtable出現的原因 : 在集合類中HashMap是比較常用的集合物件，但是HashMap是執行緒不安全的(多執行緒環境下可能會存在問題)。為了保證資料的安全性我們可以使用Hashtable，但是Hashtable採用悲觀鎖的形式把整張表鎖起來，幾乎所有方法都用synchronized修飾，效率低下。

程式碼實現 :


import java.util.HashMap;
import java.util.Hashtable;

public class MyHashtableDemo {
    public static void main(String[] args) throws InterruptedException {
        Hashtable<String, String> hm = new Hashtable<>();

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 25; i++) {
                hm.put(i + "", i + "");
            }
        });


        Thread t2 = new Thread(() -> {
            for (int i = 25; i < 51; i++) {
                hm.put(i + "", i + "");
            }
        });

        t1.start();
        t2.start();

        System.out.println("----------------------------");
        //為了t1和t2能把資料全部新增完畢
        Thread.sleep(1000);

        //0-0 1-1 ..... 50- 50

        for (int i = 0; i < 51; i++) {
            System.out.println(hm.get(i + ""));
        }//0 1 2 3 .... 50


    }
}

併發工具類-ConcurrentHashMap基本使用

ConcurrentHashMap出現的原因 : 在集合類中HashMap是比較常用的集合物件，但是HashMap是執行緒不安全的(多執行緒環境下可能會存在問題)。為了保證資料的安全性我們可以使用Hashtable，但是Hashtable的效率低下。

基於以上兩個原因我們可以使用JDK1.5以後所提供的ConcurrentHashMap。

體系結構 :

總結 :

1 ，HashMap是執行緒不安全的。多執行緒環境下會有資料安全問題

2 ，Hashtable是執行緒安全的，但是會將整張表鎖起來，效率低下

3，ConcurrentHashMap也是執行緒安全的，效率較高。在JDK7和JDK8中，底層原理不一樣。

程式碼實現 :


import java.util.Hashtable;
import java.util.concurrent.ConcurrentHashMap;

public class MyConcurrentHashMapDemo {
    public static void main(String[] args) throws InterruptedException {
        ConcurrentHashMap<String, String> hm = new ConcurrentHashMap<>(100);

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 25; i++) {
                hm.put(i + "", i + "");
            }
        });


        Thread t2 = new Thread(() -> {
            for (int i = 25; i < 51; i++) {
                hm.put(i + "", i + "");
            }
        });

        t1.start();
        t2.start();

        System.out.println("----------------------------");
        //為了t1和t2能把資料全部新增完畢
        Thread.sleep(1000);

        //0-0 1-1 ..... 50- 50

        for (int i = 0; i < 51; i++) {
            System.out.println(hm.get(i + ""));
        }//0 1 2 3 .... 50
    }
}

併發工具類-ConcurrentHashMap1.7原理

HashEntry[]小陣列初始化容量為2，預設載入因子0.75，每次擴容2倍
大陣列初始化容量16，其長度不會變化，及其容量固定為16
相當於16個HashMap連在一起，這樣每次只需要鎖住一個HashEntry就可以實現悲觀鎖
在預設情況下最多允許16個執行緒同時訪問

併發工具類-ConcurrentHashMap1.8原理

雜湊表（陣列+連結串列+紅黑樹的結合體）
結合CAS機制和synchronized同步程式碼塊保證執行緒安全
總結 :

1，如果使用空參構造建立ConcurrentHashMap物件，則什麼事情都不做。在第一次新增元素的時候建立雜湊表

2，計算當前元素應存入的索引。

3，如果該索引位置為null，則利用cas演算法，將本結點新增到陣列中。

4，如果該索引位置不為null，則利用volatile關鍵字獲得當前位置最新的結點地址，掛在他下面，變成連結串列。

5，當連結串列的長度大於等於8時，自動轉換成紅黑樹
6，以連結串列或者紅黑樹頭結點為鎖物件，配合悲觀鎖保證多執行緒操作集合時資料的安全性

併發工具類-CountDownLatch

CountDownLatch類 :

方法	解釋
public CountDownLatch(int count)	引數傳遞執行緒數，表示等待執行緒數量
public void await()	讓執行緒等待
public void countDown()	當前執行緒執行完畢

使用場景： 讓某一條執行緒等待其他執行緒執行完畢之後再執行

程式碼實現 :


import java.util.concurrent.CountDownLatch;

public class ChileThread1 extends Thread {

    private CountDownLatch countDownLatch;
    public ChileThread1(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
    }

    @Override
    public void run() {
        //1.吃餃子
        for (int i = 1; i <= 10; i++) {
            System.out.println(getName() + "在吃第" + i + "個餃子");
        }
        //2.吃完說一聲
        //每一次countDown方法的時候，就讓計數器-1
        countDownLatch.countDown();
    }
}


import java.util.concurrent.CountDownLatch;

public class ChileThread2 extends Thread {

    private CountDownLatch countDownLatch;
    public ChileThread2(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
    }
    @Override
    public void run() {
        //1.吃餃子
        for (int i = 1; i <= 15; i++) {
            System.out.println(getName() + "在吃第" + i + "個餃子");
        }
        //2.吃完說一聲
        //每一次countDown方法的時候，就讓計數器-1
        countDownLatch.countDown();
    }
}


import java.util.concurrent.CountDownLatch;

public class ChileThread3 extends Thread {

    private CountDownLatch countDownLatch;
    public ChileThread3(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
    }
    @Override
    public void run() {
        //1.吃餃子
        for (int i = 1; i <= 20; i++) {
            System.out.println(getName() + "在吃第" + i + "個餃子");
        }
        //2.吃完說一聲
        //每一次countDown方法的時候，就讓計數器-1
        countDownLatch.countDown();
    }
}


import java.util.concurrent.CountDownLatch;

public class MotherThread extends Thread {
    private CountDownLatch countDownLatch;
    public MotherThread(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
    }

    @Override
    public void run() {
        //1.等待
        try {
            //當計數器變成0的時候，會自動喚醒這裡等待的執行緒。
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //2.收拾碗筷
        System.out.println("媽媽在收拾碗筷");
    }
}


import java.util.concurrent.CountDownLatch;

public class MyCountDownLatchDemo {
    public static void main(String[] args) {
        //1.建立CountDownLatch的物件，需要傳遞給四個執行緒。
        //在底層就定義了一個計數器，此時計數器的值就是3
        CountDownLatch countDownLatch = new CountDownLatch(3);
        //2.建立四個執行緒物件並開啟他們。
        MotherThread motherThread = new MotherThread(countDownLatch);
        motherThread.start();

        ChileThread1 t1 = new ChileThread1(countDownLatch);
        t1.setName("小明");

        ChileThread2 t2 = new ChileThread2(countDownLatch);
        t2.setName("小紅");

        ChileThread3 t3 = new ChileThread3(countDownLatch);
        t3.setName("小剛");

        t1.start();
        t2.start();
        t3.start();
    }
}

總結 :

1. CountDownLatch(int count)：引數寫等待執行緒的數量。並定義了一個計數器。

2. await()：讓執行緒等待，當計數器為0時，會喚醒等待的執行緒

3. countDown()：執行緒執行完畢時呼叫，會將計數器-1。

併發工具類-Semaphore

使用場景 :

可以控制訪問特定資源的執行緒數量。

實現步驟 :

1，需要有人管理這個通道

2，當有車進來了，發通行許可證

3，當車出去了，收回通行許可證

4，如果通行許可證發完了，那麼其他車輛只能等著

程式碼實現 :


import java.util.concurrent.Semaphore;

public class MyRunnable implements Runnable {
    //1.獲得管理員物件，
    private Semaphore semaphore = new Semaphore(2);
    @Override
    public void run() {
        //2.獲得通行證
        try {
            semaphore.acquire();
            //3.開始行駛
            System.out.println("獲得了通行證開始行駛");
            Thread.sleep(2000);
            System.out.println("歸還通行證");
            //4.歸還通行證
            semaphore.release();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}


public class MySemaphoreDemo {
    public static void main(String[] args) {
        MyRunnable mr = new MyRunnable();

        for (int i = 0; i < 100; i++) {
            new Thread(mr).start();
        }
    }
}

java多執行緒與併發 - 執行緒池詳解
2018-03-13
Java執行緒
java多執行緒與併發 - 併發工具類
2018-03-09
Java執行緒
Java執行緒池進階
2022-02-27
Java執行緒
Java併發之執行緒池系列 (1) 讓多執行緒不再坑爹的執行緒池
2019-03-31
Java執行緒
java多執行緒9：執行緒池
2021-12-20
Java執行緒
Java執行緒的併發工具類
2021-06-17
Java執行緒
Java 併發：執行緒、執行緒池和執行器全面教程
2024-03-18
Java執行緒
進階Java多執行緒
2021-03-10
Java執行緒
【Java】【多執行緒】執行緒池簡述
2018-04-17
Java執行緒
Java多執行緒-執行緒池的使用
2021-01-17
Java執行緒
多執行緒【執行緒池】
2021-02-20
執行緒
Java併發——執行緒池ThreadPoolExecutor
2018-08-30
Java執行緒thread
Java併發系列 — 執行緒池
2019-01-04
Java執行緒
JAVA多執行緒併發
2020-12-21
Java執行緒
多執行緒系列(十六) -常用併發原子類詳解
2024-03-11
執行緒
JAVA重點類多執行緒
2020-10-20
Java執行緒
Java進階05 多執行緒
2019-11-21
Java執行緒
Java多執行緒學習（八）執行緒池與Executor 框架
2019-03-01
Java執行緒框架
《Java 高階篇》七：執行緒和執行緒池
2024-10-02
Java執行緒
Java併發之執行緒池系列 (2) 使用ThreadPoolExecutor構造執行緒池
2019-04-01
Java執行緒thread
Java執行緒池二：執行緒池原理
2020-12-20
Java執行緒
深入淺出Java多執行緒(十二)：執行緒池
2024-03-13
Java執行緒
java多執行緒：執行緒池原理、阻塞佇列
2020-10-08
Java執行緒佇列
66.QT-執行緒併發、QTcpServer併發、QThreadPool執行緒池
2021-07-06
QT執行緒TCPServerthread
Android多執行緒之執行緒池
2018-10-07
Android執行緒
kuangshenshuo-多執行緒-執行緒池
2020-10-21
執行緒
多執行緒之手撕執行緒池
2024-09-24
執行緒
深入理解Java多執行緒與併發框（第⑪篇）——執行緒池引數
2020-03-31
Java執行緒
java多執行緒10：併發工具類CountDownLatch、CyclicBarrier和Semaphore
2021-12-22
Java執行緒CountDownLatch
多執行緒併發篇——如何停止執行緒
2019-03-03
執行緒
Java多執行緒之進階篇
2020-09-26
Java執行緒
C#多執行緒開發-執行緒池03
2021-09-06
C#執行緒
併發工具類（一）等待多執行緒的CountDownLatch
2019-01-22
執行緒CountDownLatch
Java併發基礎（2）------執行緒池
2019-06-10
Java執行緒
java併發程式設計——執行緒池
2019-02-12
Java程式設計執行緒
走進Java Android 的執行緒世界（二）執行緒池
2018-12-04
JavaAndroid執行緒
java多執行緒3：原子性，可見性，有序性
2020-04-23
Java執行緒
多執行緒與高併發(二)執行緒安全
2019-06-30
執行緒

【重學Java】多執行緒進階（執行緒池、原子性、併發工具類）

執行緒池

執行緒狀態介紹

執行緒池-基本原理

執行緒池-Executors預設執行緒池

執行緒池-Executors建立指定上限的執行緒池

執行緒池-ThreadPoolExecutor

執行緒池-引數詳解

執行緒池-非預設任務拒絕策略

阿里巴巴關於執行緒池的規範

原子性

volatile-問題

volatile解決

synchronized解決

原子性

volatile關鍵字不能保證原子性

原子性_AtomicInteger

AtomicInteger-記憶體解析

AtomicInteger-原始碼解析

悲觀鎖和樂觀鎖

併發工具類

併發工具類-Hashtable

併發工具類-ConcurrentHashMap基本使用

併發工具類-ConcurrentHashMap1.7原理

併發工具類-ConcurrentHashMap1.8原理

併發工具類-CountDownLatch

併發工具類-Semaphore

相關文章