LockSupport原理分析

phoenixsky 發(fā)布于2019-08-15 15:31 / 1003人閱讀

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

一. LockSupport類介紹

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

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

當(dāng)調(diào)用unpark(thread)方法，就會將thread線程的許可permit設(shè)置成1(注意多次調(diào)用unpark方法，不會累加，permit值還是1)。
當(dāng)調(diào)用park()方法，如果當(dāng)前線程的permit是1，那么將permit設(shè)置為0，并立即返回。如果當(dāng)前線程的permit是0，那么當(dāng)前線程就會阻塞，直到別的線程將當(dāng)前線程的permit設(shè)置為1.park方法會將permit再次設(shè)置為0，并返回。

注意：因為permit默認(rèn)是0，所以一開始調(diào)用park()方法，線程必定會被阻塞。調(diào)用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;

// 簡易的先進(jìn)先出非重入鎖
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);

        // 如果當(dāng)前線程不是等待線程隊列第一個，或者locked狀態(tài)已經(jīng)是true，那么當(dāng)前線程就要等待
        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");
            // 等待線程的中斷線程標(biāo)志位為true，就設(shè)置wasInterrupted為true
            if (Thread.interrupted())
                wasInterrupted = true;
        }

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

    // 喚醒可能等待的線程
    public void unlock() {
        System.out.println(Thread.currentThread().getName()+"  unpark start ");
        // 將locked設(shè)置為false
        locked.set(false);
        // 喚醒當(dāng)前線程隊列中第一個元素
        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方法會阻塞當(dāng)前線程，unpark(thread)方法，會立即喚醒被阻塞的線程，讓它從park方法處繼續(xù)執(zhí)行。

三. LockSupport源碼注釋

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

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

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

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

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

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

    // 阻塞當(dāng)前線程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);
        }
    }
    // 阻塞當(dāng)前線程，超過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);
    }

    // 阻塞當(dāng)前線程，不設(shè)置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系列阻塞當(dāng)前線程的方法，以及unpark喚醒某個線程的方法。

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

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

對于WAITING等待狀態(tài)有兩種喚醒方式：

調(diào)用對應(yīng)的喚醒方法。這里就是LockSupport的unpark方法。
調(diào)用該線程變量的interrupt()方法，會喚醒該線程，并拋出InterruptedException異常。

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

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

文章版權(quán)歸作者所有，未經(jīng)允許請勿轉(zhuǎn)載,若此文章存在違規(guī)行為，您可以聯(lián)系管理員刪除。

轉(zhuǎn)載請注明本文地址：http://systransis.cn/yun/69112.html

發(fā)表評論

登陸后可評論

0條評論

phoenixsky

男|高級講師

我要關(guān)注我要私信

TA的文章

tensorflow1.12.0

閱讀 3464·2023-04-25 19:39
#黑色#ITLDC：KVM VPS年付5折 €16.49/年起，100M不限流量，多國機房可選

閱讀 3817·2021-11-18 13:12
怎么云主機里開網(wǎng)站-云主機怎么使用？

閱讀 3642·2021-09-22 15:45
分銷主機是什么-代理主機名是什么？

閱讀 2441·2021-09-22 15:32
如何管理你下載的一大堆Python包【??win環(huán)境及l(fā)inux環(huán)境下創(chuàng)建虛擬環(huán)境詳解??】

閱讀 727·2021-09-04 16:40
前端面試資源整理（一）

閱讀 3739·2019-08-30 14:11
javascript新手實例1-DOM基本操作

閱讀 1893·2019-08-30 13:46
6.18快要來臨--家具電商大戰(zhàn)一觸即發(fā)

閱讀 1574·2019-08-29 15:43

成人国产在线小视频_日韩寡妇人妻调教在线播放_色成人www永久在线观看_2018国产精品久久_亚洲欧美高清在线30p_亚洲少妇综合一区_黄色在线播放国产_亚洲另类技巧小说校园_国产主播xx日韩_a级毛片在线免费

資訊專欄INFORMATION COLUMN

上云采購季！| 2核2G4M爆款云服務(wù)器低至59元/年，更有多臺、長期優(yōu)惠，快來選購！

LockSupport原理分析

相關(guān)文章

**淺談Java并發(fā)編程系列（八）—— LockSupport原理剖析**

FutureTask源碼分析筆記

Java并發(fā)編程，Condition的await和signal等待通知機制

AbstractQueuedSynchronizer的介紹和原理分析

AbstractQueuedSynchronizer 原理分析 - Condition 實現(xiàn)原理

發(fā)表評論

0條評論

phoenixsky

男|高級講師

TA的文章

tensorflow1.12.0

#黑色#ITLDC：KVM VPS年付5折 €16.49/年起，100M不限流量，多國機房可選

怎么云主機里開網(wǎng)站-云主機怎么使用？

分銷主機是什么-代理主機名是什么？

如何管理你下載的一大堆Python包【??win環(huán)境及l(fā)inux環(huán)境下創(chuàng)建虛擬環(huán)境詳解??】

前端面試資源整理（一）

javascript新手實例1-DOM基本操作

6.18快要來臨--家具電商大戰(zhàn)一觸即發(fā)

最新活動

資訊專欄INFORMATION COLUMN

上云采購季！| 2核2G4M爆款云服務(wù)器低至59元/年，更有多臺、長期優(yōu)惠，快來選購！

LockSupport原理分析

相關(guān)文章

發(fā)表評論

0條評論

男|高級講師

TA的文章

最新活動

上云采購季！| 2核2G4M爆款云服務(wù)器低至59元/年，更有多臺、長期優(yōu)惠，快來選購！