Java並發編程系列之LockSupport的用法

Posted on by

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操作
  • 操縱對象屬性
  • 操縱數組元素
  • 直接操縱內存

總結

本篇文章就到這裡瞭，希望能夠給你帶來幫助，也希望您能夠多多關註WalkonNet的更多內容!

推薦閱讀：