02.JUC核心篇：LockSupport

LockSupport

线程阻塞工具类（LockSupport）：所有方法都是静态方法，可以让线程在任意位置阻塞和唤醒。

LockSupport类使用了一种名为Permit（许可）的概念来做到阻塞和唤醒线程的功能，可以把许可看成是一种(0,1)信号量(Semaphore)，但与Semaphore不同的是，许可的累加上限是1.

初始时，permit为0，当调用unpark方法的时候，线程的permit加1，当调用park方法的时候，如果permit为0，则调用线程进入阻塞状态。

简单来说：park是等待一个许可，unpark是为某线程提供一个许可

• 如果线程A调用park，那么除非另一个线程调用unpark(A)给A一个许可，否则线程A将阻塞在park操作上。

区别于wait/notify

• wait和notify都是Object中的方法，在调用这两个方法前必须先获得锁对象，但是park不需要获取某个对象的锁就可以锁住线程。
• notify只能随机选择一个线程唤醒，无法唤醒指定的线程，unpark可以唤醒一个指定的线程。

注：

• unpark不会对wait起作用，notify也不会对park起作用。
• park在中断或唤醒后，不会像sleep一样去清除interrupt标志位，也不清楚自身是否是由于中断被唤醒，所以需要自己手动去查看是否被中断标记Thread.interrupted()。

需要特别注意的是：LockSupport底层使用Posix线程库pthreads的系统级别锁互斥量mutex和condition，所以它的系统消耗是非常大的，尽量降低使用它的频率。

如：在AQS类中会再三确认是否无法获得锁，当确实无法获取锁的时候，那么park等待被唤醒后再去抢锁。

源码分析

Java底层每个线程都会有一个Parker实例与之对应，Parker实例主要来维护_counter变量。

• _counter = 0：没有permit（许可），而park操作的目的就是等待直到 _counter从1设置为0成功。
• _counter = 1：有一个parmit（许可），而unpark的目的就是设置 _counter为1（调用多次也是1而不会累加）。

park底层原理流程图

具体底层源码：UNSAFE.park

void Parker::park(bool isAbsolute, jlong time) {  
    // 若 _counter > 0 直接设置 _counter=0并返回
    if (Atomic::xchg(0, &_counter) > 0) return;   
    // mutex加锁
    ThreadBlockInVM tbivm(jt);  
    // no wait needed  
    if (_counter > 0)  { 
        // 如果 _counter > 0，直接设置 _counter=0解锁mutex，并返回
        _counter = 0;  
        //解锁mutex
        status = pthread_mutex_unlock(_mutex);   
        return;
    }
    if (time == 0) {  
        // 否则，condition条件等待，直到unpark()调用pthread_cond_signal() 唤醒后，继续向下执行
        status = pthread_cond_wait (_cond, _mutex) ;   
    }  
    // 唤醒后，直接设置_counter为0
    _counter = 0 ;  
    // 结束mutex
    status = pthread_mutex_unlock(_mutex) ;    
    assert_status(status == 0, status, "invariant") ;  
    OrderAccess::fence();
}

unpark底层原理流程图

具体底层源码：UNSAFE.unpark

void Parker::unpark() {  
    int s, status ;  
    status = pthread_mutex_lock(_mutex);   // 互斥量mutex加锁
    assert (status == 0, "invariant") ;   // 是否成功判断
    s = _counter;  
    _counter = 1;   //直接设置_counter为1
    /**
     * 此时
     * 若 _counter = 0，说明park() 方法此时可能在睡眠中等待一个permit，需要unpark的signal唤醒
     * 若 _counter = 1，说明本身就是有permit的，没有park()在此时睡眠，不用做额外操作
     */
    if (s < 1) {   // 判断_counter是否为0
        if (WorkAroundNPTLTimedWaitHang) {  
            status = pthread_cond_signal (_cond) ;  
            assert (status == 0, "invariant") ;  
            status = pthread_mutex_unlock(_mutex);  
            assert (status == 0, "invariant") ;  
        } else {  
            status = pthread_mutex_unlock(_mutex);  
            assert (status == 0, "invariant") ;  
            status = pthread_cond_signal (_cond) ;  
            assert (status == 0, "invariant") ;  
        }  
    } else {  
        pthread_mutex_unlock(_mutex);  
        assert (status == 0, "invariant") ;  
    }    // 无论 _counter 旧值为几，最后都是要mutex解锁的，因为unpark最开始加了mutex锁。不做会导致mutex锁一直存在无法被其他线程获取到mutex锁
} 

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<?> 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); }
}

阻塞

park()

// 在许可可用之前阻塞当前线程
// 如果许可可用，则使用该许可，并且该调用立即返回
// 否则，为线程调度禁用当前线程，并在发生以下三种情况之一以前，使其处于休眠状态
// 1. 其他线程将当前线程作为目标调用unpark
// 2. 其他线程中断当前线程
// 3. 该调用不合逻辑地返回
// 此方法并不报告是哪个线程导致该方法返回。调用者应该重新检查最先导致线程暂停的条件。调用者还可以确定线程返回时的中断状态
public static void park() {
    UNSAFE.park(false, 0L);
}

park(Object blocker)

// blocker：导致线程暂停的同步对象（既线程被谁阻塞的），用于线程监控和分析工具来定位原因。
public static void park(Object blocker) {
    // 获取当前线程
    Thread t = Thread.currentThread();
    // 将当前线程的parkBlocker字段设置为blocker（既线程t是被blocker阻塞的）
    setBlocker(t, blocker);
    // 阻塞当前线程，参数一：表示isAbsolute，是否为绝对时间，参数二：代表时间
    UNSAFE.park(false, 0L);
    setBlocker(t, null);
}

parkUntil(long deadline)

// 和park()方法类似，不过增加了等待的绝对时间
public static void parkUntil(long deadline) {
    UNSAFE.park(true, deadline);
}

parkUntil(Object blocker, long deadline)

// 将当前线程阻塞绝对时间的deadline秒，并且将当前线程的parkBlockerOffset设置为blocker
public static void parkUntil(Object blocker, long deadline) {
    // 获取当前线程
    Thread t = Thread.currentThread();
    // 设置当前线程parkBlocker字段设置为blocker
    setBlocker(t, blocker);
    // 阻塞当前线程绝对时间的deadline秒
    UNSAFE.park(true, deadline);
    // 当前线程parkBlocker字段设置为null
    setBlocker(t, null);
}

parkNanos(long nanos)

// 和park()方法类似，不过增加了等待的相对时间
public static void parkNanos(long nanos) {
    if (nanos > 0)
        UNSAFE.park(false, nanos);
}

parkNanos(Object blocker, long nanos)

// 阻塞当前线程nanos秒
public static void parkNanos(Object blocker, long nanos) {
    // 先判断nanos是否大于0，小于等于0都代表无限等待
    if (nanos > 0) {
      	// 获取当前线程
        Thread t = Thread.currentThread();
      	// 将当前线程的parkBlocker字段设置为blocker
        setBlocker(t, blocker);
      	// 阻塞当前线程
        UNSAFE.park(false, nanos);
      	// 将当前线程的parkBlocker字段设置为null
        setBlocker(t, null);
    }
}

唤醒

unpark

// 如果给定线程的许可尚不可用，则使其可用
// 如果线程在park上受阻塞，则将它解除阻塞状态
// 否则，保证下次调用park不会受阻塞
// 如果给定线程尚未启动，则无法保证此操作有任何效果
// thread：要执行unpark操作的线程，该参数为null表示此操作没有任何效果。
public static void unpark(Thread thread) {
    if (thread != null)
        UNSAFE.unpark(thread);
}

赏

谢谢你请我吃糖果

支付宝

微信