Java中Synchronized的原理與使用場景及Callable介面的使用方法及區別分析

一、基本特點

1. 開始時是樂觀鎖定, 如果鎖定衝突頻繁, 就轉換為悲觀鎖定.

2. 開始是輕量級鎖實現, 如果鎖被持有的時間較長, 就轉換成重量級鎖.

3. 實現輕量級鎖的時候大概率用到的自旋鎖策略

4. 是一種不公平鎖定

5. 是一種可重入鎖定

#6. 不是讀寫鎖定

二、加鎖工作流程

JVM 將synchronized 鎖分為無鎖、偏向鎖、輕量級鎖定、重量級鎖定狀態。會根據情況，進行依序升級。

偏向鎖

假設男主角是個鎖, 女主角是一個執行緒. 如果只有這一個執行緒來使用這個鎖, 那麼男主女主即使不領證結婚(避免了高成本操作), 也可以一直幸福的生活下去. 但是女配出現了, 也嘗試競爭男主, 此時不管領證結婚這個操作成本多高, 女主也勢必要把這個動作完成了, 讓女配死心

偏向鎖不是真的"加鎖", 只是給對象頭中做一個"偏向鎖的標記", 記錄這個鎖屬於哪個線程. 如果後續沒有其他線程來競爭該鎖, 那麼就不用進行其他同步操作了(避免了加鎖解鎖的開銷) 如果後續有其他線程來競爭該鎖(剛才已經在鎖對像中記錄了當前鎖屬於哪個線程了, 很容易識別當前申請鎖的線程是不是之前記錄的線程), 那就取消原來的偏向鎖狀態, 進入一般的輕量級鎖狀態

偏向鎖本質上相當於"延遲加鎖" . 能不加鎖就不加鎖, 盡量來避免不必要的加鎖開銷. 但是該做的標記還是得做的, 否則無法區分何時需要真正加鎖

偏向鎖不是真的加鎖, 而只是在鎖的對象頭中記錄一個標記(記錄該鎖所屬的線程). 如果沒有其他線程參與競爭鎖, 那麼就不會真正執行加鎖操作, 從而降低程序開銷. 一旦真的涉及到其他的線程競爭, 再取消偏向鎖狀態, 進入輕量級鎖狀態

輕量級鎖

隨著其他線程進入競爭, 偏向鎖狀態被消除, 進入輕量級鎖狀態(自適應的自旋鎖定). 此處的輕量級鎖定就是透過CAS 來實現.

透過CAS 檢查並更新一塊記憶體(例如null => 該線程引用)

如果更新成功, 則認為加鎖成功

如果更新失敗, 則認為鎖被佔用, 繼續自旋式的等待(並不放棄CPU).

自旋操作是一直讓CPU 空轉, 比較浪費CPU 資源. 因此此處的自旋不會一直持續進行, 而是達到一定的時間/重試次數, 就不再自旋了. 也就是所謂的"自適應"

重量級鎖定

如果競爭進一步激烈, 自旋不能快速獲取到鎖狀態, 就會膨脹為重量級鎖此處的重量級鎖就是指用到內核提供的mutex .

執行加鎖操作, 先進入內核態.

在內核態判定當前鎖是否已被佔用

如果該鎖沒有佔用, 則加鎖成功, 並切換回用戶狀態.

如果該鎖定被佔用, 則加鎖失敗. 此時執行緒進入鎖定的等待佇列, 掛起. 等待被作業系統喚醒.

##經歷了一系列的滄海桑田, 這個鎖被其他線程釋放了, 操作系統也想起了這個掛起的線程, 於是喚醒這個線程, 嘗試重新獲取鎖

三、其他的優化操作

鎖消除

編譯器JVM 判斷鎖是否可消除. 如果可以, 就直接消除

有些應用程式的程式碼中, 用到了synchronized, 但其實沒有在多執行緒環境下. (例如StringBuffer )

StringBuffer sb = new StringBuffer();
sb.append("a");
sb.append("b");
sb.append("c");
sb.append("d");

此時每個append 的呼叫都會涉及加鎖和解鎖. 但如果只是在單線程中執行這個代碼, 那麼這些加鎖解鎖操作是沒有必要的, 白白浪費了一些資源開銷.

鎖定粗化

一段邏輯中如果出現多次加鎖解鎖, 編譯器JVM 會自動進行鎖的粗化.

領導, 給下屬交代工作任務

方式一:

打電話, 交代任務1, 掛電話.

打電話, 交代任務2, 掛電話.

打電話, 交代任務3, 掛電話

方式二:

#打電話, 交代任務1, 任務2, 任務3, 掛電話

#四、Callable 介面

Callable 是什麼

Callable 是個interface .相當於把執行緒封裝了一個"傳回值".方便程式猿借助多執行緒的方式計算結果.

Callable 和 Runnable 相对, 都是描述一个 "任务". Callable 描述的是带有返回值的任务, Runnable 描述的是不带返回值的任务.Callable 通常需要搭配 FutureTask 来使用. FutureTask 用来保存 Callable 的返回结果. 因为 Callable 往往是在另一个线程中执行的, 啥时候执行完并不确定. FutureTask 就可以负责这个等待结果出来的工作.

代码示例: 创建线程计算 1 + 2 + 3 + ... + 1000, 不使用 Callable 版本

public class Text {
 
    static class Result{
        public int sum = 0;
        public Object locker = new Object();
    }
 
    public static void main(String[] args) throws InterruptedException {
        Result result = new Result();
 
        Thread t = new Thread(){
            @Override
            public void run() {
                int sum = 0;
                for (int i = 0; i <=10000; i++){
                    sum += i;
                }
                result.sum = sum;
 
                synchronized (result.locker){
                    result.locker.notify();
                }
            }
        };
        t.start();
        synchronized (result.locker){
            while (result.sum == 0){
                result.locker.wait();
            }
        }
        System.out.println(result.sum);
    }
}

代码示例: 创建线程计算 1 + 2 + 3 + ... + 1000, 使用 Callable 版本

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
 
public class Text1 {
 
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int sum = 0;
                for (int i = 0; i <=1000; i++){
                    sum += i;
                }
                return sum;
            }
        };
        //由于Thread不能直接传一个callable实例，就需要一个辅助类来包装
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        Thread t = new Thread(futureTask);
        t.start();
        //尝试在主线程获取结果
        //如果FutureTask中的结果还没生成。此时就会阻塞等待
        //一直等到最终的线程把这个结果算出来，get返回
        Integer result = futureTask.get();
        System.out.println(result);
    }
}

以上是Java中Synchronized的原理與使用場景及Callable介面的使用方法及區別分析的詳細內容。更多資訊請關注PHP中文網其他相關文章！