第十四天：執行緒池+執行緒工具類-有解無憂

1.執行緒池

1.1 執行緒狀態介紹

當執行緒被創建并啟動以后，它既不是一啟動就進入了執行狀態，也不是一直處于執行狀態，執行緒物件在不同的時期有不同的狀態，那么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	一個完全運行完成的執行緒的狀態，也稱之為終止狀態、結束狀態

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

執行緒狀態

1.2 執行緒池-基本原理

概述 :

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

執行緒池存在的意義：

? 系統創建一個執行緒的成本是比較高的，因為它涉及到與作業系統互動，當程式中需要創建大量生存期很短暫的執行緒時，頻繁的創建和銷毀執行緒對系統的資源消耗有可能大于業務處理是對系

? 統資源的消耗，這樣就有點"舍本逐末"了，針對這一種情況，為了提高性能，我們就可以采用執行緒池，執行緒池在啟動的時，會創建大量空閑執行緒，當我們向執行緒池提交任務的時，執行緒池就

? 會啟動一個執行緒來執行該任務，等待任務執行完畢以后，執行緒并不會死亡，而是再次回傳到執行緒池中稱為空閑狀態，等待下一次任務的執行，

執行緒池的設計思路 :

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

1.3 執行緒池-Executors默認執行緒池

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

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

? static ExecutorService newCachedThreadPool() 創建一個默認的執行緒池
static newFixedThreadPool(int nThreads) 創建一個指定最多執行緒數量的執行緒池

代碼實作 :

//static ExecutorService newCachedThreadPool()   創建一個默認的執行緒池
//static 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();
    }
}

1.4 執行緒池-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();
    }
}

1.5 執行緒池-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 {
//    引數一：核心執行緒數量
//    引數二：最大執行緒數
//    引數三：空閑執行緒最大存活時間
//    引數四：時間單位
//    引數五：任務佇列
//    引數六：創建執行緒工廠
//    引數七：任務的拒絕策略
    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();
    }
}

1.6 執行緒池-引數詳解

創建執行緒池物件的七個引數

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

1.7 執行緒池-非默認任務拒絕策略

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()方法繞過執行緒池直接執行，

2. 原子性

2.1 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;
    }
}

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

2.2 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;
    }
}

2.3 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;
        }
    }
}

2.4 原子性

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

代碼實作 :

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++ 不是一個原子性操作, 他在執行的程序中,有可能被其他執行緒打斷

2.5 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 + "個冰淇淋");
            }
        }
    }
}

2.6 原子性_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());
    }
}

2.7 AtomicInteger-記憶體決議

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

CAS演算法：

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

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

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

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

2.8 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;
}

2.9 悲觀鎖和樂觀鎖

synchronized和CAS的區別 :

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

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

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

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

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

3. 并發工具類

3.1 并發工具類-Hashtable

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

代碼實作 :

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


    }
}

3.2 并發工具類-ConcurrentHashMap基本使用

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

基于以上兩個原因我們可以使用JDK1.5以后所提供的ConcurrentHashMap，

體系結構 :
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
    }
}

3.3 并發工具類-ConcurrentHashMap1.7原理

ConcurrentHashMap1.7底層

3.4 并發工具類-ConcurrentHashMap1.8原理

ConcurrentHashMap1.8底層

總結 :

? 1，如果使用空參構造創建ConcurrentHashMap物件，則什么事情都不做，在第一次添加元素的時候創建哈希表

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

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

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

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

3.5 并發工具類-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，

3.6 并發工具類-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();
        }
    }
}

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

標籤：python

上一篇：java中的clone方法的使用

下一篇：[Java筆記]day13