whenComplete

    public static void main(String[] args) throws ExecutionException, InterruptedException
    {
        ExecutorService threadPool = Executors.newFixedThreadPool(3);
        try
        {
            CompletableFuture.supplyAsync(
                    () -> {
                System.out.println(Thread.currentThread().getName() + "----come in");
                int result = ThreadLocalRandom.current().nextInt(10);
                try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
                System.out.println("-----1秒钟后出结果：" + result);
                if(result > 2)
                {
                    int i=10/0;
                }
                return result;
            },threadPool)
			        //v是上面的回傳值
                    .whenComplete((v,e) -> {
                if (e == null) {
                    System.out.println("-----计算完成，更新系统UpdateValue："+v);
                }
            }).exceptionally(e -> {
                e.printStackTrace();
                System.out.println("异常情况："+e.getCause()+"\t"+e.getMessage());
                return null;
            });

            System.out.println(Thread.currentThread().getName()+"线程先去忙其它任务");
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            threadPool.shutdown();
        }
        //主執行緒不要立刻結束，否則CompletableFuture預設使用的執行緒池會立刻關閉:暫停3秒鐘執行緒
        //try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }
    }

將list中儲存的List<NetMall>取出轉化成List<CompletableFuture<String>>再轉換成List<String>

用到stream中的中間方法map Java SE/新特性/Stream流#中间方法

將NetMall物件轉換為一個CompletableFuture物件，並回傳一個代表非同步計算結果的CompletableFuture物件

不使用lambda的寫法

public static List<String> getPriceByCompletableFuture(List<NetMall> list,String productName)  
{  
    return list.stream().map(netMall -> CompletableFuture.supplyAsync(() -> String.format(productName + " in %s price is %.2f",netMall.getNetMallName(),netMall.calcPrice(productName)))).collect(Collectors.toList())//終結方法，將第一次計算的結果收集到一個列表  
            .stream()//再次呼叫stream()方法將列表轉換為一個新的流  
            .map(s -> s.join())//接著,使用map()方法對串流中的每個元素 s 進行轉換操作  
            .collect(Collectors.toList());//將所有的物件收集到一個列表中  
}

thenApply、handle 兩者作用相同handle可以處理例外

thenRun 不需要前一步的結果，會使用之前的執行緒池 thenRunAsync 非同步，會使用ForkJoinPool，不使用自訂執行緒池 thenAccept需要前一步結果，無傳回值，它傳回的是一個新的 CompletableFuture<Void> thenApply需要前一步結果，有傳回值 thenRunAsync 會使用ForkJoinPool，不使用自訂執行緒池

join() 方法會阻塞目前執行緒，等待非同步工作執行完成。這樣可以確保在需要取得非同步工作結果的地方，能夠取得最終的結果

• thenRunAsync

System.out.println(CompletableFuture.supplyAsync(() -> "resultA").thenRun(() -> {}).join());//null  
System.out.println(CompletableFuture.supplyAsync(() -> "resultA").thenAccept(r -> System.out.println(r)).join());//resultA和null,這個為thenAccept的傳回結果  
System.out.println(CompletableFuture.supplyAsync(() -> "resultA").thenAccept(r -> System.out.println(r)));  
//resultA和java.util.concurrent.CompletableFuture@76fb509a[Completed normally] 這個為thenAccept的傳回結果 ，此時由於沒有執行完沒有結果
System.out.println(CompletableFuture.supplyAsync(() -> "resultA").thenApply(r -> r + "resultB").join());//resultAresultB

applyToEither A.applyToEither(B, c -> { return c + " is winer"; });

CompletableFuture<String> playA = CompletableFuture.supplyAsync(() -> {  
    System.out.println("A come in");  
    try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }  
    return "playA";  
});  
  
CompletableFuture<String> playB = CompletableFuture.supplyAsync(() -> {  
    System.out.println("B come in");  
    try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }  
    return "playB";  
});  
  
CompletableFuture<String> result = playA.applyToEither(playB, f -> {  
    return f + " is winer";  
});  
  
System.out.println(Thread.currentThread().getName()+"\t"+"-----: "+result.join());

x.thenCombine(y,(x,y)->{})

兩個CompletionStage工作完成後，把兩個completableFuture的結果一起交給thenCombine來處理

CompletableFuture result = completableFuture1.thenCombine(completableFuture2, (x, y) -> {
System.out.println("-----开始两个结果合并");
return x + y;
});

位元組碼 monitorenter/monitorexit 來控制鎖的進出 一個 enter，兩個exit

如果有例外，為一個 enter，一個 exit

在 Java 位元碼層面上，synchronized 關鍵字的實作依賴於monitorenter和monitorexit這兩個指令。每個 Java 物件都隱含地關聯著一個監視器鎖（monitor）。當執行monitorenter指令時，執行緒嘗試取得與物件關聯的監視器鎖的所有權。當執行monitorexit指令時，執行緒釋放該監視器鎖。

執行緒執行要求先持有管程

每個物件都天生帶一個物件監視器，每個被鎖住的物件都和 Monitor 關聯起來

其中_owner會指向持有鎖的執行緒，誰持有，誰記錄，誰釋放，誰取消

1. 非公平鎖降低執行緒切換開銷
2. 非公平鎖利用率高

非公平：吞吐量，節省時間 公平：雨露均霑

jsp -l jstack process ID

或者使用圖形化工具，例如 jconsole

在需要中斷的執行緒不斷監聽中斷狀態

• volatile volatile，當volatile為 true 時中斷執行緒，然後在另外一個執行緒更改狀態

• AtomicBoolean

• interrupt

就是把對應執行緒的 interrupt 設定為 True，自己搭配 while 進行 break，可以達到上面程式碼類似的效果

先wait後notify 必須在同步程式碼區塊或同步方法中成對出現

t1 ----come in t2 ----send notification t1 ----be awakened

t1 被喚醒後，會從 wait() 方法處嘗試重新取得 objectLock 的鎖

先取得鎖Lock.lock() condition.await(); condition.signal();

可見性：一旦改變所有執行緒可見

java中的普通共享變數沒有保證可見性，也就是說主記憶體的共享變數沒有和共享變數副本進行同步，此時就需要將修改的資料同步到主記憶體過，且其他執行緒從主記憶體更新

主執行緒所做的修改也只是修改變數副本，並沒有直接刷新到主記憶體，也需要後續刷新

資料彼此沒有依賴，執行效果一致就可以重排

語句四不可能被重排到第一個

解決，有兩種方式

規律，XXYY XX先執行後再執行YY

StoreLoad防止後續的 volatile 讀操作重排，但也間接的防止 volatile 寫操作（因為 volatile 寫前本身會再加StoreStore），可能間接地防止普通寫重排，也可能不防止

第一個操作和第二個操作代表程式碼中的先後順序

如果不禁止重排，那麼 volatile 讀操作之後的普通讀寫操作可能會被重排到 volatile 讀操作之前，從而破壞了 happens-before 關係，導致程式行為不可預測。 普通讀寫操作很可能依賴於 volatile 讀操作的結果

當第二個操作為volatile寫時，不論第一個操作是什麼，都不能重排序。這個操作保證了volatile寫之前的操作不會被重排到volatile寫之後

雖然通常說 StoreLoad 有防止後續的 volatile 讀或寫操作重排序到 volatile 寫操作之前的作用，但實際上它也間接起到了防止在前的普通讀操作被重排序到 volatile 寫之後的作用。

就算volatile寫前沒有加loadstore，JVM仍然可以透過以下方式保證程式正確

讀之後的操作不會重排到讀之前 寫之前的操作不會重排到寫之後

volatile寫：在每個volatile寫操作前或後插入一個StoreStotre/Storeload屏障 volatile Read在每個volatile Read操作後插入一個LoadLoad,LoadStore屏障

volatile int v = 0;
int a = 0;

void example() {
    v = a; // volatile Write
    a = 1; // Normal Write
}

在這個例子中，有兩個操作：
1. `v = a;` 是一個 `volatile` 寫操作。
2. `a = 1;` 是一個普通寫操作。

根據表格中的規則：
1. `volatile` 寫操作之後的普通寫操作是可以重排的。
2. `volatile` 寫操作之後的 `volatile` 寫操作是不可以重排的。

**as-if-serial語意:** 無論怎麼重排序（編譯器和處理器為了提高並行度），單執行緒下的執行結果都不能被改變。
Happens-Before 規則的應用: 儘管 a = 1; 發生在 v = a; 之後，但根據資料依賴性，為了得到正確的v，實際上 a 的賦值 happens-before v = a。
總結：

- 儘管 JMM 允許 `volatile` 寫操作之後的普通寫操作重排，但是在存在資料依賴關係的情況下，JMM 會阻止這種重排序。

不加volatile程式不會停止，主執行緒做出的修改也是修改變數副本，沒有刷新到主記憶體，也有可能刷到了主記憶體，但另一個執行緒使用的還是副本，沒有從主記憶體取得最新值

只能保證可見性，從主記憶體直接讀取與儲存資料，而多執行緒的操作同樣可能出錯 原子性需要lock

例如 i++ 正確結果 10000，測試結果 8177

根據上面的變數讀寫過程

int x = 0; volatile int v = 0; int y = 0;

// Thread A x = 1; // 普通寫入操作 v = y; // volatile 寫入操作 y = 1; // 普通寫入操作

執行緒A中的操作順序

在Thread A中，我們有三步操作：

1. x = 1; （普通寫入操作）
2. v = y; （volatile寫入操作）
3. y = 1; （普通寫入操作）

重排序規則

根據Java記憶體模型，volatile寫入操作會在其前後插入記憶體屏障：

1. 寫屏障（Store Barrier）：在寫入volatile變數之前，確保所有之前的普通寫入操作都已經完成並對其他執行緒可見。
2. 讀屏障（Load Barrier）：在讀取volatile變數之後，確保所有後續的普通讀取操作讀取到最新的值。

針對你的問題：普通寫入操作是否會被重排到volatile寫入操作之前

在Thread A中：

• x = 1 是普通寫入操作。
• v = y 是volatile寫入操作。
• y = 1 是普通寫入操作。

根據記憶體模型的規則：

• volatile寫入操作之前的所有普通寫入操作不能被重排到volatile寫入操作之後。
• 但是，volatile寫入操作之後的普通寫入操作是可以被重排到volatile寫入操作之前的。

具體範例

考慮以下程式碼：

x = 1; / 普通寫入操作 v = y; / volatile 寫入操作 y = 1; / 普通寫入操作

在這種情況下，可能會發生以下重排序：

• x = 1 和 v = y 的順序是固定的，x = 1 必須在 v = y 之前完成。
• 但是 y = 1 可能會被重排序到 v = y 之前。

因此，可能的執行順序包括：

1. x = 1
2. y = 1
3. v = y

對執行緒B的影響

對於Thread B：

int r1 = v; / volatile 讀取操作 int r2 = x; / 普通讀取操作 int r3 = y; / 普通讀取操作

有很多讀,降低開銷,不用加鎖,只需要保證可見性即可

雙檢

第二次加鎖因為:可能別的執行緒在開始檢查時沒有建立完成,而檢查鎖時正好建立完成釋放了鎖

由於SafeDoubleCheckSingleton沒有加volatile singleton = new SafeDoubleCheckSingleton(); 這行程式碼實際上分為三個步驟：

1. 為 SafeDoubleCheckSingleton 分配記憶體空間。
2. 呼叫 SafeDoubleCheckSingleton 的建構函式來初始化物件。
3. 將 singleton 參照指向分配的記憶體位址。

由於重排序,可能進行到第二步,物件還沒有建立完畢,另一個執行緒進行判斷以為物件已經建立完成,導致出錯,因此需要volatile保證不會發生重排

如果主記憶體是 5,多執行緒共享變數副本是 5,更新 6 後準備寫入主記憶體時,會檢查共享變數副本是否依舊和主記憶體相等,相等則認為沒有別的執行緒修改,否則將不更新,重新讀取主記憶體的值

• 硬體級別保證

它透過硬體級別的指令（如 cmpxchg 指令）來確保比較-更新操作的原子性。這樣可以避免傳統鎖機制帶來的執行緒阻塞和上下文切換開銷，從而提高系統的效率和回應速度。

package com.atguigu.Interview.study.thread;

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

/**
 * @auther zzyy
 * @create 2018-12-28 17:57
 * 題目：實作一個自旋鎖
 * Spin lock advantage: looping comparison to acquire without similar wait blocking.
 *
 * Through CAS operation completes the spin lock,A the thread that comes in first calls myLock method and holds the lock itself 5 seconds,B then after coming in finds
 * currently a thread holds the lock, not null，so it can only wait by spinning, until A after the lock is released B then grabs it.
 */
public class SpinLockDemo
{
    AtomicReference<Thread> atomicReference = new AtomicReference<>();

    public void myLock()
    {
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName()+"\t come in");
        while(!atomicReference.compareAndSet(null,thread))
        {

        }
    }

    public void myUnLock()
    {
        Thread thread = Thread.currentThread();
        atomicReference.compareAndSet(thread,null);
        System.out.println(Thread.currentThread().getName()+"\t myUnLock over");
    }

    public static void main(String[] args)
    {
        SpinLockDemo spinLockDemo = new SpinLockDemo();

        new Thread(() -> {
            spinLockDemo.myLock();
            try { TimeUnit.SECONDS.sleep( 5 ); } catch (InterruptedException e) { e.printStackTrace(); }
            spinLockDemo.myUnLock();
        },"A").start();


        //Pause the thread for a while, to ensure A the thread runs before B the thread starts and completes
        try { TimeUnit.SECONDS.sleep( 1 ); } catch (InterruptedException e) { e.printStackTrace(); }

        new Thread(() -> {
            spinLockDemo.myLock();
            spinLockDemo.myUnLock();
        },"B").start();

    }
}

執行緒 A 修改記憶體中的資料時，執行緒 B 過來使用了資料，B 改變資料後，又將資料恢復成原樣，對於執行緒 A 檢查後以為沒有變過而修改成功，出現了過程不安全問題 因此引用了版本號機制, AtomicStampedReference

new AtomicReference<>();

將之前設置的z3轉換成li4

AtomicMarkableReference,它允許你原子性地更新一個參照和一個boolean標記位。

true/false的更改

class BankAccount//resource class
{
    String bankName = "CCB";
    //更新的物件屬性必須使用 public volatile 修飾符。
    public volatile int money = 0;//錢數
    public void add()
    {
        money++;
    }
    //因為物件的屬性修改類型原子類都是抽象類，所以每次使用都必須
    //使用靜態方法newUpdater()建立一個更新器，並且需要設定想要更新的類和屬性
    AtomicIntegerFieldUpdater<BankAccount> fieldUpdater =
            AtomicIntegerFieldUpdater.newUpdater(BankAccount.class,"money");

    //不加synchronized，保證高效能原子性，局部微創小手術
    public void transMoney(BankAccount bankAccount)
    {
        fieldUpdater.getAndIncrement(bankAccount);
    }
}

/**
 * @auther zzyy
 * 以一種執行緒安全的方式操作非執行緒安全物件的某些欄位。
 *
 * 需求：
 * 10個執行緒，
 * 每個執行緒轉帳1000，
 * 不使用synchronized,嘗試使用AtomicIntegerFieldUpdater來實作。
 */

public class AtomicIntegerFieldUpdaterDemo
{
    public static void main(String[] args) throws InterruptedException
    {
        BankAccount bankAccount = new BankAccount();
        CountDownLatch countDownLatch = new CountDownLatch(10);

        for (int i = 1; i <=10; i++) {
            new Thread(() -> {
                try {
                    for (int j = 1; j <=1000; j++) {
                        //bankAccount.add();
                        bankAccount.transMoney(bankAccount);
                    }
                } finally {
                    countDownLatch.countDown();
                }
            },String.valueOf(i)).start();
        }
        countDownLatch.await();

        System.out.println(Thread.currentThread().getName()+"\t"+"result: "+bankAccount.money);
    }
}

class MyVar //資源類
{
    public volatile Boolean isInit = Boolean.FALSE;

    AtomicReferenceFieldUpdater<MyVar,Boolean> referenceFieldUpdater =
            AtomicReferenceFieldUpdater.newUpdater(MyVar.class,Boolean.class,"isInit");

    public void init(MyVar myVar)
    {
        if (referenceFieldUpdater.compareAndSet(myVar,Boolean.FALSE,Boolean.TRUE))
        {
            System.out.println(Thread.currentThread().getName()+"\t"+"----- start init,need 2 seconds");
            //暫停幾秒鐘執行緒
            try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println(Thread.currentThread().getName()+"\t"+"----- over init");
        }else{
            System.out.println(Thread.currentThread().getName()+"\t"+"----- 已经有线程在进行初始化工作。。。。。");
        }
    }
}


/**
 * @auther zzyy
 * 需求：
 * 多執行緒並行呼叫一個類的初始化方法，如果未被初始化過，將執行初始化工作，
 * 要求只能被初始化一次，只有一個執行緒操作成功
 */
 
public class AtomicReferenceFieldUpdaterDemo
{
    public static void main(String[] args)
    {
        MyVar myVar = new MyVar();

        for (int i = 1; i <=5; i++) {
            new Thread(() -> {
                myVar.init(myVar);
            },String.valueOf(i)).start();
        }
    }
}

對比測試，效能相差 10 倍

import javax.lang.model.element.VariableElement;
import java.util.HashMap;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.LongAccumulator;
import java.util.concurrent.atomic.LongAdder;

class ClickNumber //資源類
    //四種計算方式,測試效能
{
    int number = 0;
    public synchronized void clickBySynchronized()
    {
        number++;
    }

    AtomicLong atomicLong = new AtomicLong(0);
    public void clickByAtomicLong()
    {
        atomicLong.getAndIncrement();
    }

    LongAdder longAdder = new LongAdder();
    public void clickByLongAdder()
    {
        longAdder.increment();
    }

    LongAccumulator longAccumulator = new LongAccumulator((x,y) -> x + y,0);
    public void clickByLongAccumulator()
    {
        longAccumulator.accumulate(1);
    }

}

/**
 * @auther zzyy
 * 需求： 50個執行緒，每個執行緒100W次，總點讚數出來
 */
public class AccumulatorCompareDemo
{
    public static final int _1W = 10000;
    public static final int threadNumber = 50;

    public static void main(String[] args) throws InterruptedException
    {
        ClickNumber clickNumber = new ClickNumber();
        long startTime;
        long endTime;

        CountDownLatch countDownLatch1 = new CountDownLatch(threadNumber);
        CountDownLatch countDownLatch2 = new CountDownLatch(threadNumber);
        CountDownLatch countDownLatch3 = new CountDownLatch(threadNumber);
        CountDownLatch countDownLatch4 = new CountDownLatch(threadNumber);

        startTime = System.currentTimeMillis();
        for (int i = 1; i <=threadNumber; i++) {
            new Thread(() -> {
                try {
                    for (int j = 1; j <=100 * _1W; j++) {
                        clickNumber.clickBySynchronized();
                    }
                } finally {
                    countDownLatch1.countDown();
                }
            },String.valueOf(i)).start();
        }
        countDownLatch1.await();
        endTime = System.currentTimeMillis();
        System.out.println("----costTime: "+(endTime - startTime) +" 毫秒"+"\t clickBySynchronized: "+clickNumber.number);

        startTime = System.currentTimeMillis();
        for (int i = 1; i <=threadNumber; i++) {
            new Thread(() -> {
                try {
                    for (int j = 1; j <=100 * _1W; j++) {
                        clickNumber.clickByAtomicLong();
                    }
                } finally {
                    countDownLatch2.countDown();
                }
            },String.valueOf(i)).start();
        }
        countDownLatch2.await();
        endTime = System.currentTimeMillis();
        System.out.println("----costTime: "+(endTime - startTime) +" 毫秒"+"\t clickByAtomicLong: "+clickNumber.atomicLong.get());


        startTime = System.currentTimeMillis();
        for (int i = 1; i <=threadNumber; i++) {
            new Thread(() -> {
                try {
                    for (int j = 1; j <=100 * _1W; j++) {
                        clickNumber.clickByLongAdder();
                    }
                } finally {
                    countDownLatch3.countDown();
                }
            },String.valueOf(i)).start();
        }
        countDownLatch3.await();
        endTime = System.currentTimeMillis();
        System.out.println("----costTime: "+(endTime - startTime) +" 毫秒"+"\t clickByLongAdder: "+clickNumber.longAdder.sum());

        startTime = System.currentTimeMillis();
        for (int i = 1; i <=threadNumber; i++) {
            new Thread(() -> {
                try {
                    for (int j = 1; j <=100 * _1W; j++) {
                        clickNumber.clickByLongAccumulator();
                    }
                } finally {
                    countDownLatch4.countDown();
                }
            },String.valueOf(i)).start();
        }
        countDownLatch4.await();
        endTime = System.currentTimeMillis();
        System.out.println("----costTime: "+(endTime - startTime) +" 毫秒"+"\t clickByLongAccumulator: "+clickNumber.longAccumulator.get());

    }
}

LongAdder是Striped64的子類

Striped64原始碼

CAS只允許一個執行緒成功修改共享變數的值，其餘執行緒會失敗並重試，當並行量高時會出現非常多的重試，而LongAdder內部維護了一個基於CAS的cell陣列。每個cell獨立維護一個計數值。會對每個cell都可以有一個執行緒進入然後進行更新，多個執行緒可以操作不同的cell，最後只需要將每個cell累加，得到結果 LongAdder等於 base 變數加 Cell[]陣列

(as 等於 cells) 不等於 null ： 檢查 cells 陣列是否已初始化，初始化為ture 未初始化則進行，!casBase(b = base, b + x)，嘗試使用 CAS 操作直接更新基礎計數器 base。

一個 base，然後新建兩個 cell

案例測試每個執行緒記錄自己的資料

import java.util.Random;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;

class House //資源類
{
    int saleCount = 0;
    public synchronized void saleHouse()
    {
        ++saleCount;
    }

    ThreadLocal<Integer> saleVolume = ThreadLocal.withInitial(() -> 0);
    public void saleVolumeByThreadLocal()
    {
        saleVolume.set(1+saleVolume.get());
    }
}

/**
 * @auther zzyy
 * @create 2021-12-31 15:46
 * 需求1： 5個銷售賣房子，集團高層只關心銷售總量的準確統計數。
 * 需求2： 5個銷售賣完隨機數房子，各自獨立銷售額度，自己業績按提成走，分灶吃飯，各個銷售自己動手，豐衣足食
 */

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

        House house = new House();

        for (int i = 1; i <=5; i++) {
            new Thread(() -> {
                int size = new Random().nextInt(5)+1;
                try {
                    for (int j = 1; j <=size; j++) {
                        house.saleHouse();
                        house.saleVolumeByThreadLocal();
                    }
                    System.out.println(Thread.currentThread().getName()+"\t"+"号销售卖出："+house.saleVolume.get());
                } finally {
                    house.saleVolume.remove();
                }
            },String.valueOf(i)).start();
        };

        //暫停毫秒
        try { TimeUnit.MILLISECONDS.sleep(300); } catch (InterruptedException e) { e.printStackTrace(); }

        System.out.println(Thread.currentThread().getName()+"\t"+"共计卖出多少套： "+house.saleCount);
    }
}

軟引用 通常用於對記憶體敏感的程式中，例如快取就有用到軟引用，記憶體夠用時就保留，不夠用就回收

弱引用: 發現就回收

虛引用: 顧名思義，就是形同虛設，與其他幾種引用都不同，虛引用並不會決定物件的生命週期。 設定虛引用關聯的唯一目的，就是在這個物件被收集器回收時收到一個系統通知，或者後續新增進一步的處理。

Entry 擴充了 WeakReference<ThreadLocal<?>>，這意味著它持有一個 ThreadLocal<?> 物件的弱引用

使用弱引用回收後 Entry 的 key 就會指向 null

由於在執行緒池情境下,執行緒池經常被重複使用 Object value; 此時僅僅使用弱引用,就會存在很多key為ull的entry,但value一直存在也會再引發新的記憶體洩漏,因此需要remove手動清理

值是強引用的主要原因，是為了確保執行緒區域變數的值在鍵存在的情況下可以被正常存取。如果值也是弱引用，那麼在垃圾回收時，即使鍵還存在，值也可能被回收，這樣會導致意外的行為。

set、get方法會去檢查所有鍵為null的Entry物件

類型指標被壓縮了,從8個壓縮到了4個 -XX:+UseCompressedClassPointers

<!--
官網：http://openjdk.java.net/projects/code-tools/jol/
定位：分析物件在JVM的大小和分布
-->
<dependency>
    <groupId>org.openjdk.jol</groupId>
    <artifactId>jol-core</artifactId>
    <version>0.9</version>
</dependency>


ackage com.atguigu.juc.senior.inner.object;
import org.openjdk.jol.vm.VM;
/**
 * @auther zzyy
 * @create 2020-06-13 11:24
 */
public class MyObject
{
    public static void main(String[] args){
        //VM的細節詳細情況
        System.out.println(VM.current().details());
        //所有的物件配置的位元組都是8的整數倍。
        System.out.println(VM.current().objectAlignment());
    }
}

使用者態與核心態是描述作業系統中不同權限等級的術語。 使用者態執行於較低權限等級，主要用於一般應用程式，限制對硬體與系統資源的直接存取。 核心態執行於最高權限等級，允許對所有硬體與系統資源進行直接存取與控制，主要用於作業系統核心與關鍵系統服務。

Mutex Lock

無鎖：初始狀態，一個物件被實例化後，如果沒有被任何執行緒競爭鎖，那麼就是無鎖狀態

0 4 的 01 代表無鎖

物件雖然產生了，但是沒有呼叫 hashcode 是不會記錄 hash 編碼的

從右下角往上看 unused

https://www.bilibili.com/video/BV1ar4y1x727?p=124&vd_source=17535a06cd4587318e9b67ac64afeab7

最後八位

由物件標頭中

預設開啟，但是有延遲 4 秒，延遲時可能跳過偏向鎖加上輕量鎖

java -XX:+PrintFlagsInitial | grep BiasedLock*

或等待 5 秒，偏向鎖開啟的時候

1. 該執行緒執行完
2. 另一個執行緒進行搶奪

當有另外執行緒逐步來競爭鎖的時候，就不能再使用偏向鎖了，要升級為輕量級鎖

競爭執行緒嘗試CAS更新物件頭失敗，會等待到全局安全點（此時不會執行任何程式碼）撤銷偏向鎖。

偏鎖不能和雜湊碼共存 如果在使用鎖前計算雜湊碼會直接升級為輕量鎖 如果在使用鎖時計算雜湊碼會直接升級為重量鎖

輕量鎖可以共存

當物件計算過雜湊碼後，就不能進入鎖，否則就會造成編碼錯亂 o.hashCode()

鎖消除

鎖粗化

將當前最新的 node 設定為 head node.thread = null; node.prev = null; 當 node 成功取得鎖後，thread 變數就不再需要了。此時，node 已經成為佇列的頭節點，執行緒資訊不再需要保留在節點中。透過將 thread 欄位設定為 null，可以幫助垃圾回收器回收不再需要的物件，從而避免記憶體洩漏 取得後就不需要 thread 了