LockSupport原理分析

phoenixsky 發布于2019-08-15 15:31 / 994人閱讀

摘要：此對象在線程受阻塞時被記錄，以允許監視工具和診斷工具確定線程受阻塞的原因。調用該線程變量的方法，會喚醒該線程，并拋出異常。對于等待狀態來說，它比狀態多了一種喚醒方式，就是超過規定時間，那么線程會自動醒來。

一. LockSupport類介紹

LockSupport類可以阻塞當前線程以及喚醒指定被阻塞的線程。主要是通過park()和unpark(thread)方法來實現阻塞和喚醒線程的操作的。

每個線程都有一個許可(permit)，permit只有兩個值1和0,默認是0。

當調用unpark(thread)方法，就會將thread線程的許可permit設置成1(注意多次調用unpark方法，不會累加，permit值還是1)。

當調用park()方法，如果當前線程的permit是1，那么將permit設置為0，并立即返回。如果當前線程的permit是0，那么當前線程就會阻塞，直到別的線程將當前線程的permit設置為1.park方法會將permit再次設置為0，并返回。

注意：因為permit默認是0，所以一開始調用park()方法，線程必定會被阻塞。調用unpark(thread)方法后，會自動喚醒thread線程，即park方法立即返回。

二. LockSupport類示例

import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.locks.LockSupport;

// 簡易的先進先出非重入鎖
class FIFOMutex {
    //
    private final AtomicBoolean locked = new AtomicBoolean(false);
    // 記錄等待線程隊列
    private final Queue waiters = new ConcurrentLinkedQueue();

    public void lock() {
        boolean wasInterrupted = false;
        Thread current = Thread.currentThread();
        waiters.add(current);

        // 如果當前線程不是等待線程隊列第一個，或者locked狀態已經是true，那么當前線程就要等待
        while (waiters.peek() != current || !locked.compareAndSet(false, true)) {
            System.out.println(Thread.currentThread().getName()+"  park start");
            LockSupport.park(this);
            System.out.println(Thread.currentThread().getName()+"  park end");
            // 等待線程的中斷線程標志位為true，就設置wasInterrupted為true
            if (Thread.interrupted())
                wasInterrupted = true;
        }

        // 移除第一個元素。當前線程就是第一個元素，因為while判斷條件
        waiters.remove();
        // 如果wasInterrupted為true，當前線程發出中斷請求
        if (wasInterrupted)
            current.interrupt();
        System.out.println(Thread.currentThread().getName()+" lock end" );
    }

    // 喚醒可能等待的線程
    public void unlock() {
        System.out.println(Thread.currentThread().getName()+"  unpark start ");
        // 將locked設置為false
        locked.set(false);
        // 喚醒當前線程隊列中第一個元素
        LockSupport.unpark(waiters.peek());
        System.out.println(Thread.currentThread().getName()+"  unpark end ");
    }
}


public class LockSupportTest {

    public static void startThread(String name, final FIFOMutex clock, final CountDownLatch countDownLatch) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                clock.lock();
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    System.out.println(Thread.currentThread().getName()+"  finally");
                    countDownLatch.countDown();
                    clock.unlock();
                }
            }
        }, name).start();
    }

    public static void main(String[] args) {
        FIFOMutex clock = new FIFOMutex();
        CountDownLatch countDownLatch = new CountDownLatch(3);
        startThread("t111", clock, countDownLatch);
        startThread("t222", clock, countDownLatch);
        startThread("t333", clock, countDownLatch);

        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("main end");
    }
}

從這個例子中可以看出，park方法會阻塞當前線程，unpark(thread)方法，會立即喚醒被阻塞的線程，讓它從park方法處繼續執行。

三. LockSupport源碼注釋

package java.util.concurrent.locks;
import sun.misc.Unsafe;

import java.util.concurrent.Semaphore;
import java.util.concurrent.ThreadLocalRandom;

/**
 * 提供阻塞線程和喚醒線程的方法。
 */
public class LockSupport {
    // 構造函數是私有的，所以不能在外部實例化
    private LockSupport() {}

    // 用來設置線程t的parkBlocker屬性。此對象在線程受阻塞時被記錄，以允許監視工具和診斷工具確定線程受阻塞的原因。
    private static void setBlocker(Thread t, Object arg) {
        UNSAFE.putObject(t, parkBlockerOffset, arg);
    }

    // 喚醒處于阻塞狀態下的thread線程
    public static void unpark(Thread thread) {
        // 當線程不為null時調用
        if (thread != null)
            // 通過UNSAFE的unpark喚醒被阻塞的線程
            UNSAFE.unpark(thread);
    }

    // 阻塞當前線程
    public static void park(Object blocker) {
        Thread t = Thread.currentThread();
        // 設置線程t的parkBlocker屬性，用于記錄線程阻塞情況
        setBlocker(t, blocker);
        // 通過UNSAFE的park方法阻塞線程
        UNSAFE.park(false, 0L);
        setBlocker(t, null);
    }

    // 阻塞當前線程nanos納秒時間，超出時間線程就會被喚醒返回
    public static void parkNanos(Object blocker, long nanos) {
        if (nanos > 0) {
            Thread t = Thread.currentThread();
            setBlocker(t, blocker);
            UNSAFE.park(false, nanos);
            setBlocker(t, null);
        }
    }
    // 阻塞當前線程，超過deadline日期線程就會被喚醒返回
    public static void parkUntil(Object blocker, long deadline) {
        Thread t = Thread.currentThread();
        setBlocker(t, blocker);
        UNSAFE.park(true, deadline);
        setBlocker(t, null);
    }

    // 獲取線程t的parkBlocker屬性
    public static Object getBlocker(Thread t) {
        if (t == null)
            throw new NullPointerException();
        return UNSAFE.getObjectVolatile(t, parkBlockerOffset);
    }

    // 阻塞當前線程，不設置parkBlocker屬性
    public static void park() {
        UNSAFE.park(false, 0L);
    }

    public static void parkNanos(long nanos) {
        if (nanos > 0)
            UNSAFE.park(false, nanos);
    }

    public static void parkUntil(long deadline) {
        UNSAFE.park(true, deadline);
    }

    static final int nextSecondarySeed() {
        int r;
        Thread t = Thread.currentThread();
        if ((r = UNSAFE.getInt(t, SECONDARY)) != 0) {
            r ^= r << 13;   // xorshift
            r ^= r >>> 17;
            r ^= r << 5;
        }
        else if ((r = ThreadLocalRandom.current().nextInt()) == 0)
            r = 1; // avoid zero
        UNSAFE.putInt(t, SECONDARY, r);
        return r;
    }

    // Hotspot implementation via intrinsics API
    private static final 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.getUnsafe();
            Class tk = Thread.class;
            parkBlockerOffset = UNSAFE.objectFieldOffset
                (tk.getDeclaredField("parkBlocker"));
            SEED = UNSAFE.objectFieldOffset
                (tk.getDeclaredField("threadLocalRandomSeed"));
            PROBE = UNSAFE.objectFieldOffset
                (tk.getDeclaredField("threadLocalRandomProbe"));
            SECONDARY = UNSAFE.objectFieldOffset
                (tk.getDeclaredField("threadLocalRandomSecondarySeed"));
        } catch (Exception ex) { throw new Error(ex); }
    }

}

LockSupport的源碼比較簡單，主要就是park系列阻塞當前線程的方法，以及unpark喚醒某個線程的方法。

注意，park系列的方法就是直接阻塞當前線程的，所以不需要線程變量參數。而unpark方法是喚醒對應線程的，所以必須傳遞線程變量thread。

在Java多線程詳細介紹這篇文章中，我們介紹了線程一共有六種狀態，而park系列方法線程進入兩種狀態：WAITING等待狀態或TIMED_WAITING等待狀態。這兩種狀態都會使線程阻塞在當前位置。
那么怎么喚醒這兩種狀態的線程呢？

對于WAITING等待狀態有兩種喚醒方式：

調用對應的喚醒方法。這里就是LockSupport的unpark方法。

調用該線程變量的interrupt()方法，會喚醒該線程，并拋出InterruptedException異常。

對于TIMED_WAITING等待狀態來說，它比WAITING狀態多了一種喚醒方式，就是超過規定時間，那么線程會自動醒來。

云服務器 GPU云服務器 LockSupport js跨域原理分析語音降噪圖形分析原理webrtc 排序原理

文章版權歸作者所有，未經允許請勿轉載,若此文章存在違規行為，您可以聯系管理員刪除。

轉載請注明本文地址：http://specialneedsforspecialkids.com/yun/69112.html

淺談Java并發編程系列（八）—— LockSupport原理剖析

摘要：此對象在線程受阻塞時被記錄，以允許監視工具和診斷工具確定線程受阻塞的原因。阻塞當前線程，最長不超過納秒，返回條件在的基礎上增加了超時返回。喚醒線程喚醒處于阻塞狀態的線程。 LockSupport 用法簡介 LockSupport 和 CAS 是Java并發包中很多并發工具控制機制的基礎，它們底層其實都是依賴Unsafe實現。 LockSupport是用來創建鎖和其他同步類的基本線程阻塞...

jeyhan 2019-08-14 17:36 評論0 收藏0
FutureTask源碼分析筆記

摘要：主要的實現實際上運行還是一個，它對做了一個封裝，讓開發人員可以從其中獲取返回值是有狀態的共種狀態，四種狀態變換的可能和的區別通過方法調用有返回值可以拋異常結果的實現原理判斷狀態非狀態則直接進入返回結果處于狀態，則進入等待流程獲主要的實現FutureTask # FutureTask實際上運行還是一個runnable，它對callable做了一個封裝，讓開發人員可以從其中獲取返回值； ...

PascalXie 2019-08-15 15:42 評論0 收藏0
Java并發編程，Condition的await和signal等待通知機制

摘要：是要和配合使用的也就是和是綁定在一起的，而的實現原理又依賴于，自然而然作為的一個內部類無可厚非。示意圖如下是的內部類，因此每個能夠訪問到提供的方法，相當于每個都擁有所屬同步器的引用。Condition簡介Object類是Java中所有類的父類，在線程間實現通信的往往會應用到Object的幾個方法： wait(),wait(long timeout),wait(long timeout, i...

el09xccxy 2019-05-23 16:22 評論0 收藏0
AbstractQueuedSynchronizer的介紹和原理分析

摘要：同步器擁有三個成員變量隊列的頭結點隊列的尾節點和狀態。對于同步器維護的狀態，多個線程對其的獲取將會產生一個鏈式的結構。使用將當前線程，關于后續會詳細介紹。簡介提供了一個基于FIFO隊列，可以用于構建鎖或者其他相關同步裝置的基礎框架。該同步器（以下簡稱同步器）利用了一個int來表示狀態，期望它能夠成為實現大部分同步需求的基礎。使用的方法是繼承，子類通過繼承同步器并需要實現它的方法來管理...

Yuanf 2019-08-14 11:37 評論0 收藏0
AbstractQueuedSynchronizer 原理分析 - Condition 實現原理

摘要：實現原理是通過基于單鏈表的條件隊列來管理等待線程的。中斷在轉移到同步隊列期間或之后發生，此時表明有線程正在調用轉移節點。在該種中斷模式下，再次設置線程的中斷狀態。 1. 簡介 Condition是一個接口，AbstractQueuedSynchronizer 中的ConditionObject內部類實現了這個接口。Condition聲明了一組等待/通知的方法，這些方法的功能與Objec...

leone 2019-08-16 11:15 評論0 收藏0