線程池
線程狀態介紹
當線程被創建並啟動以后，它既不是一啟動就進入了執行狀態，也不是一直處於執行狀態。線程對象在不同的時期有不同的狀態。那么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的常用方法如下：
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();
}
}
}