Java并發編程中LockSupport的用法是怎樣的

Java并發編程中LockSupport的用法是怎樣的，相信很多沒有經驗的人對此束手無策，為此本文總結了問題出現的原因和解決方法，通過這篇文章希望你能解決這個問題。

1、什么是LockSupport?

LockSupport是用于創建鎖和其他同步類的基本線程阻塞原語

2、兩類基本API

LockSupport提供了兩類最基本的API：

block線程類：一般都是以pack開頭的方法名，pack*(...)

pack方法有兩個重載的版本：blocker是一個對象，用于指定阻塞哪個對象。不知道的情況，默認以鎖對象自己this為blocker

public static void park();
public static void park(Object blocker);

拓展：parkNanos函數

public static void parkNanos(Object blocker, long nanos) {
    if (nanos > 0) { 
        // 獲取當前線程
        Thread t = Thread.currentThread();
        // 設置Blocker
        setBlocker(t, blocker);
        // 獲取許可，并設置了時間
        UNSAFE.park(false, nanos);
        // 設置許可，重新設置blocker為null，避免unpack，獲取的blocker為之前設置的
        setBlocker(t, null);
    }
}

nanos參數表示相對時間，表示等待多長時間

parkUntil函數：表示在指定的時限前禁用當前線程，deadline參數表示絕對時間，表示指定的時間

public static void parkUntil(Object blocker, long deadline) {
    // 獲取當前線程
    Thread t = Thread.currentThread();
    // 設置Blocker
    setBlocker(t, blocker);
    UNSAFE.park(true, deadline);
    // 設置Blocker為null
    setBlocker(t, null);
}

unBlock線程類：unpack(Thread)

unpack方法用于釋放許可，指定線程可以繼續運行。

3、LockSupport本質

LockSupport是一個許可的信號量機制，pack消費，unpack放入，放入也是僅一個，不累計。例如，調用unpack放入一個信號量，多次調用，這個是不會累計信號量的，pack調用之后會消費

4、LockSupport例子

例子：如何控制兩個線程依次打印1、2、3、4、5、6、…

import java.util.concurrent.locks.LockSupport;
public class LockSupportExample {
    private static final int total = 10;
    private  static int i = 0;
    static Thread t1 , t2;
    public static void main(String[] args) {
        t1 = new Thread(() ->{
            while (i < total) {
                System.out.println("t1:" + (++i));
                LockSupport.unpark(t2);
                LockSupport.park();
            }
        });
        t2 = new Thread(() -> {
            while (i < total) {
                LockSupport.park();
                System.out.println("t2:" + (++i));
                LockSupport.unpark(t1);
            }
        });
        t1.start();
        t2.start();
    }
}

打印：

t1: 1
t2: 2
t1:3
t2:4
t1:5
t2:6
t1:7
t2:8
t1:9
t2:10

5、LockSupport源碼

public class LockSupport {
    // Hotspot implementation via intrinsics API
    private static final sun.misc.Unsafe UNSAFE;
    private static final long parkBlockerOffset;
    private static final long SEED;
    private static final long PROBE;
    private static final long SECONDARY;
    static {
        try {
            // 獲取Unsafe實例
            UNSAFE = sun.misc.Unsafe.getUnsafe();
            // 線程類的class對象
            Class<?> tk = Thread.class;
            // 獲取Thread的parkBlocker字段的內存偏移地址
            parkBlockerOffset = UNSAFE.objectFieldOffset
                (tk.getDeclaredField("parkBlocker"));
            // 獲取Thread的threadLocalRandomSeed字段的內存偏移地址
            SEED = UNSAFE.objectFieldOffset
                (tk.getDeclaredField("threadLocalRandomSeed"));
            // 獲取Thread的threadLocalRandomProbe字段的內存偏移地址
            PROBE = UNSAFE.objectFieldOffset
                (tk.getDeclaredField("threadLocalRandomProbe"));
            // 獲取Thread的threadLocalRandomSecondarySeed字段的內存偏移地址
            SECONDARY = UNSAFE.objectFieldOffset
                (tk.getDeclaredField("threadLocalRandomSecondarySeed"));
        } catch (Exception ex) { throw new Error(ex); }
    }
}

pack方法的源碼：

public static void park(Object blocker) {
    // 獲取當前線程
    Thread t = Thread.currentThread();
    // 設置Blocker
    setBlocker(t, blocker);
    // 獲取許可
    UNSAFE.park(false, 0L);
    // 重新可運行后再此設置Blocker為null，避免unpack獲取到上一個設置的setBlocker(t, blocker);
    setBlocker(t, null);
}

unpack的源碼：

public static void unpark(Thread thread) {
    if (thread != null) // 線程為不空
        UNSAFE.unpark(thread); // 釋放該線程許可
}

可以看出，不管是pack的源碼還是unpack的源碼都是通過Unsafe的底層api實現的

sun.misc.Unsafe可以直接進行底層非安全操作的工具類

主要提供如下操作：

• 線程掛起與恢復

• CAS操作

• 操縱對象屬性

• 操縱數組元素

• 直接操縱內存

看完上述內容，你們掌握Java并發編程中LockSupport的用法是怎樣的的方法了嗎？如果還想學到更多技能或想了解更多相關內容，歡迎關注億速云行業資訊頻道，感謝各位的閱讀！