主頁 >  其他 > 第十四天：執行緒池+執行緒工具類

第十四天：執行緒池+執行緒工具類

2020-11-07 11:35:57 其他

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 執行緒池-基本原理

概述 :

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

執行緒池存在的意義：

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

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

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

執行緒池的設計思路 :

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

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/qita/205397.html

標籤：其他

上一篇：看精神小伙是如何智斗騙子的

下一篇：nodejs(express)之用戶注冊、登錄和授權

標籤雲
其他(157675) Python(38076) JavaScript(25376) Java(17977) C(15215) 區塊鏈(8255) C＃(7972) AI(7469) 爪哇(7425) MySQL(7132) html(6777) 基礎類(6313) sql(6102) 熊猫(6058) PHP(5869) 数组(5741) R(5409) Linux(5327) 反应(5209) 腳本語言(PerlPython)(5129) 非技術區(4971) Android(4554) 数据框(4311) css(4259) 节点.js(4032) C語言(3288) json(3245) 列表(3129) 扑(3119) C++語言(3117) 安卓(2998) 打字稿(2995) VBA(2789) Java相關(2746) 疑難問題(2699) 细绳(2522) 單片機工控(2479) iOS(2429) ASP.NET(2402) MongoDB(2323) 麻木的(2285) 正则表达式(2254) 字典(2211) 循环(2198) 迅速(2185) 擅长(2169) 镖(2155) 功能(1967) .NET技术(1958) Web開發(1951) python-3.x(1918) HtmlCss(1915) 弹簧靴(1913) C++(1909) xml(1889) PostgreSQL(1872) .NETCore(1853) 谷歌表格(1846) Unity3D(1843) for循环(1842)

熱門瀏覽
  • 網閘典型架構簡述

    網閘架構一般分為兩種：三主機的三系統架構網閘和雙主機的2+1架構網閘。 三主機架構分別為內端機、外端機和仲裁機。三機無論從軟體和硬體上均各自獨立。首先從硬體上來看，三機都用各自獨立的主板、記憶體及存盤設備。從軟體上來看，三機有各自獨立的作業系統。這樣能達到完全的三機獨立。對于“2+1”系統，“2”分為 ......

    uj5u.com 2020-09-10 02:00:44 more
  • 如何從xshell上傳檔案到centos linux虛擬機里

    如何從xshell上傳檔案到centos linux虛擬機里及：虛擬機CentOs下執行 yum -y install lrzsz命令，出現錯誤：鏡像無法找到軟體包 前言 一、安裝lrzsz步驟 二、上傳檔案 三、遇到的問題及解決方案 總結 前言 提示：其實很簡單，往虛擬機上安裝一個上傳檔案的工具 ......

    uj5u.com 2020-09-10 02:00:47 more
  • 一、SQLMAP入門

    一、SQLMAP入門 1、判斷是否存在注入 sqlmap.py -u 網址/id=1 id=1不可缺少。當注入點后面的引數大于兩個時。需要加雙引號， sqlmap.py -u "網址/id=1&uid=1" 2、判斷文本中的請求是否存在注入 從文本中加載http請求，SQLMAP可以從一個文本檔案中 ......

    uj5u.com 2020-09-10 02:00:50 more
  • Metasploit 簡單使用教程

    metasploit 簡單使用教程 浩先生， 2020-08-28 16:18:25 分類專欄： kail 網路安全 linux 文章標簽： linux資訊安全 編輯 著作權 metasploit 使用教程 前言 一、Metasploit是什么？ 二、準備作業 三、具體步驟 前言 Msfconsole ......

    uj5u.com 2020-09-10 02:00:53 more
  • 游戲逆向之驅動層與用戶層通訊

    驅動層代碼： #pragma once #include <ntifs.h> #define add_code CTL_CODE(FILE_DEVICE_UNKNOWN,0x800,METHOD_BUFFERED,FILE_ANY_ACCESS) /* 更多游戲逆向視頻www.yxfzedu.com ......

    uj5u.com 2020-09-10 02:00:56 more
  • 北斗電力時鐘（北斗授時服務器）讓網路資料更精準

    北斗電力時鐘（北斗授時服務器）讓網路資料更精準 北斗電力時鐘（北斗授時服務器）讓網路資料更精準 京準電子科技官微——ahjzsz 近幾年，資訊技術的得了快速發展，互聯網在逐漸普及，其在人們生活和生產中都得到了廣泛應用，并且取得了不錯的應用效果。計算機網路資訊在電力系統中的應用，一方面使電力系統的運行 ......

    uj5u.com 2020-09-10 02:01:03 more
  • 【CTF】CTFHub 技能樹 彩蛋 writeup

    ?碎碎念 CTFHub：https://www.ctfhub.com/ 筆者入門CTF時時剛開始刷的是bugku的舊平臺，后來才有了CTFHub。 感覺不論是網頁UI設計，還是題目質量，賽事跟蹤，工具軟體都做得很不錯。 而且因為獨到的金幣制度的確讓人有一種想去刷題賺金幣的感覺。 個人還是非常喜歡這個 ......

    uj5u.com 2020-09-10 02:04:05 more
  • 02windows基礎操作

    我學到了一下幾點 Windows系統目錄結構與滲透的作用 常見Windows的服務詳解 Windows埠詳解 常用的Windows注冊表詳解 hacker DOS命令詳解（net user / type /md /rd/ dir /cd /net use copy、批處理 等） 利用dos命令制作 ......

    uj5u.com 2020-09-10 02:04:18 more
  • 03.Linux基礎操作

    我學到了以下幾點 01Linux系統介紹02系統安裝，密碼啊破解03Linux常用命令04LAMP 01LINUX windows： win03 8 12 16 19 配置不繁瑣 Linux：redhat,centos(紅帽社區版)，Ubuntu server,suse unix:金融機構，證券，銀 ......

    uj5u.com 2020-09-10 02:04:30 more
  • 05HTML

    01HTML介紹 02頭部標簽講解03基礎標簽講解04表單標簽講解 HTML前段語言 js1.了解代碼2.根據代碼 懂得挖掘漏洞 （POST注入/XSS漏洞上傳）3.黑帽seo 白帽seo 客戶網站被黑帽植入劫持代碼如何處理4.熟悉html表單 <html><head><title>TDK標題，描述 ......

    uj5u.com 2020-09-10 02:04:36 more
最新发布
  • 2023年最新微信小程式抓包教程

    01 開門見山 隔一個月發一篇文章，不過分。 首先回顧一下《微信系結手機號資料庫被脫庫事件》，我也是第一時間得知了這個訊息，然后跟蹤了整件事情的經過。下面是這起事件的相關截圖以及近日流出的一萬條資料樣本： 個人認為這件事也沒什么，還不如關注一下之前45億快遞資料查詢渠道疑似在近日復活的訊息。 訊息是 ......

    uj5u.com 2023-04-20 08:48:24 more
  • web3 產品介紹：metamask 錢包 使用最多的瀏覽器插件錢包

    Metamask錢包是一種基于區塊鏈技術的數字貨幣錢包，它允許用戶在安全、便捷的環境下管理自己的加密資產。Metamask錢包是以太坊生態系統中最流行的錢包之一，它具有易于使用、安全性高和功能強大等優點。 本文將詳細介紹Metamask錢包的功能和使用方法。 一、 Metamask錢包的功能 數字資 ......

    uj5u.com 2023-04-20 08:47:46 more
  • vulnhub_Earth

    前言 靶機地址->>>vulnhub_Earth 攻擊機ip：192.168.20.121 靶機ip：192.168.20.122 參考文章 https://www.cnblogs.com/Jing-X/archive/2022/04/03/16097695.html https://www.cnb ......

    uj5u.com 2023-04-20 07:46:20 more
  • 從4k到42k，軟體測驗工程師的漲薪史，給我看哭了

    清明節一過，盲猜大家已經無心上班，在數著日子準備過五一，但一想到銀行卡里的余額……瞬間心情就不美麗了。最近，2023年高校畢業生就業調查顯示，本科畢業月平均起薪為5825元。調查一出，便有很多同學表示自己又被平均了。看著這一資料，不免讓人想到前不久中國青年報的一項調查：近六成大學生認為畢業10年內會 ......

    uj5u.com 2023-04-20 07:44:00 more
  • 最新版本 Stable Diffusion 開源 AI 繪畫工具之中文自動提詞篇

    🎈 標簽生成器 由于輸入正向提示詞 prompt 和反向提示詞 negative prompt 都是使用英文，所以對學習母語的我們非常不友好 使用網址：https://tinygeeker.github.io/p/ai-prompt-generator 這個網址是為了讓大家在使用 AI 繪畫的時候 ......

    uj5u.com 2023-04-20 07:43:36 more
  • 漫談前端自動化測驗演進之路及測驗工具分析

    隨著前端技術的不斷發展和應用程式的日益復雜，前端自動化測驗也在不斷演進。隨著 Web 應用程式變得越來越復雜，自動化測驗的需求也越來越高。如今，自動化測驗已經成為 Web 應用程式開發程序中不可或缺的一部分，它們可以幫助開發人員更快地發現和修復錯誤，提高應用程式的性能和可靠性。 ......

    uj5u.com 2023-04-20 07:43:16 more
  • CANN開發實踐：4個DVPP記憶體問題的典型案例解讀

    摘要：由于DVPP媒體資料處理功能對存放輸入、輸出資料的記憶體有更高的要求（例如，記憶體首地址128位元組對齊），因此需呼叫專用的記憶體申請介面，那么本期就分享幾個關于DVPP記憶體問題的典型案例，并給出原因分析及解決方法。 本文分享自華為云社區《FAQ_DVPP記憶體問題案例》，作者：昇騰CANN。 DVPP ......

    uj5u.com 2023-04-20 07:43:03 more
  • msf學習

    msf學習 以kali自帶的msf為例 一、msf核心模塊與功能 msf模塊都放在/usr/share/metasploit-framework/modules目錄下 1、auxiliary 輔助模塊，輔助滲透（埠掃描、登錄密碼爆破、漏洞驗證等） 2、encoders 編碼器模塊，主要包含各種編碼 ......

    uj5u.com 2023-04-20 07:42:59 more
  • Halcon軟體安裝與界面簡介

    1. 下載Halcon17版本到到本地 2. 雙擊安裝包后 3. 步驟如下 1.2 Halcon軟體安裝 界面分為四大塊 1. Halcon的五個助手 1) 影像采集助手：與相機連接，設定相機引數，采集影像 2) 標定助手：九點標定或是其它的標定，生成標定檔案及內參外參，可以將像素單位轉換為長度單位 ......

    uj5u.com 2023-04-20 07:42:17 more
  • 在MacOS下使用Unity3D開發游戲

    第一次發博客，先發一下我的游戲開發環境吧。 去年2月份買了一臺MacBookPro2021 M1pro(以下簡稱mbp)，這一年來一直在用mbp開發游戲。我大致分享一下我的開發工具以及使用體驗。 1、Unity 官網鏈接： https://unity.cn/releases 我一般使用的Apple ......

    uj5u.com 2023-04-20 07:40:19 more

Copyright © 2010-2020 有解無憂