1、带着面试题学习

1. 为什么LockSupport也是核心基础类?
2. LockSupport.park()会释放锁资源吗?
3. 如果在wait()之前执行了notify()会怎样?
4. 如果在park()之前执行了unpark()会怎样?

2、介绍

2.1、LockSupport类简介

LockSupport是用于创建锁和其他同步类的线程阻塞基本原语。

某个线程调用LockSupport.park，如果对应的“许可证”可用，则此次调用立即返回，否则线程将会阻塞直到中断发生、超时或者许可证状态变为可用。

线程调用LockSupport.unpark 可以使许可证变得可用。许可证只有一个，不会累积，多次调用unpark没什么用。

2.2、LockSupport使用场景

场景比较简单：就是对线程的阻塞和唤醒

上周讲到AQS中当线程需要阻塞时就将其放到同步队列中，等到该唤醒时就将其移除队列并唤醒，使其继续工作。
而AQS里面对线程的阻塞和唤醒就是用LockSupport实现。

2.3、LockSupport使用示例

源码里贴了一个使用的例子，用LockSupport实现了一个先入先出的不可重入锁

public class FIFOMutex {
    
    private final AtomicBoolean locked = new AtomicBoolean(false);
    private final Queue<Thread> waiters = new ConcurrentLinkedQueue<Thread>();

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

        // 当前线程不在队首或还未锁住  peek:取队首，但不会让元素出队
        while (waiters.peek() != current ||
                !locked.compareAndSet(false, true)) {
    
            LockSupport.park(this);
            if (Thread.interrupted()) // ignore interrupts while waiting
                wasInterrupted = true;
        }

        waiters.remove();
        if (wasInterrupted)          // reassert interrupt status on exit
            current.interrupt();
    }

    public void unlock() {
    
        locked.set(false);
        LockSupport.unpark(waiters.peek());
    }
}

3、源码解析

3.1 类属性

可以看到，主要是一个Unsafe对象（可以直接操作内存的，并发包底层基本都用他） 和一些Thread的属性

从静态语句块可以看的出来，先是通过反射机制获取Thread类的parkBlocker字段对象。然后通过sun.misc.Unsafe对象的objectFieldOffset方法获取到parkBlocker在内存里的偏移量，parkBlockerOffset的值就是这么来的.

为什么用反射而不是getter/ setter?
这个parkBlocker就是在线程处于阻塞的情况下才会被赋值。线程都已经阻塞了，如果不通过这种内存的方法，而是直接调用线程内的方法，线程是不会回应调用的。

// Hotspot implementation via intrinsics API
private static final sun.misc.Unsafe UNSAFE;
// 表示内存偏移地址: parkBlocker用于记录线程被谁阻塞的，用于线程监控和分析工具来定位原因。parkBlocker是Thread的属性。
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); }
}

3.2 类方法

3.2.1 方法总览

// 设置线程t的parkBlocker字段的值为arg
private static void setBlocker(Thread t, Object arg) {...}

// 提供许可，唤醒park的线程
public static void unpark(Thread thread) {...}

// 阻塞调用线程直到线程中断或者许可证状态变为可用，如果许可证可用则立即返回
public static void park(Object blocker) {...}

// 阻塞调用线程直到线程中断、等待nanos纳秒或许可证状态变为可用，如果许可证可用则立即返回
public static void parkNanos(Object blocker, long nanos) {...}

// 阻塞调用线程直到线程中断、到来截止时间(毫秒)或者许可证状态变为可用，如果许可证可用则立即返回
public static void parkUntil(Object blocker, long deadline) {...} 

// 返回造成线程park的对象
public static Object getBlocker(Thread t) {...}

// 同上park方法，只不过这里不需要设置blocker
public static void park() {...}

// 同上parkNanos方法，只不过这里不需要设置blocker
public static void parkNanos(long nanos) {...}

// 同上parkUntil方法，只不过这里不需要设置blocker
public static void parkUntil(long deadline) {...}

// 返回伪随机初始化或更新的辅助种子。 由于程序包访问限制，从ThreadLocalRandom复制。
// 说实话，这个方法没看懂...或者说他这个SECONDARY有什么用
static final int nextSecondarySeed() {...}

3.3 重点方法代码展开

3.3.1 park

park用于挂起当前线程，如果许可可用，会立马返回，并消费掉许可。

/**
 * 除非有许可，否则出于线程调度目的禁用当前线程。
 *
 * 如果许可证可用，则将其消耗掉，并立即返回；
 * 否则，出于线程调度的目的，当前线程将被禁用，并处于休眠状态，直到发生以下三种情况之一：
 *
 * <ul>
 * <li>1. 其他一些线程以当前线程为目标来调用{@link #unpark unpark};
 *
 * <li>2. 其他一些线程中断当前线程 {@linkplain Thread#interrupt interrupts};
 *
 * <li>3. 虚假的调用返回 (没有原因); 笔者：这说的啥，我也没看懂
 * </ul>
 *
 * <p>此方法不报告上述那种情况导致方法返回。
 * 调用者应重新检查导致线程首先停滞的条件。 调用者还可以确定例如返回时线程的中断状态。
 *
 * @param blocker 使线程阻塞的这个对象
 * @since 1.6
 */
public static void park(Object blocker) {
    // 获取当前线程
    Thread t = Thread.currentThread();
    // 设置blocker
    setBlocker(t, blocker);
    // 调用unsafe的park方法(可能会阻塞)
    UNSAFE.park(false, 0L);
    // unsafe.park方法返回后，把blocker置为null
    setBlocker(t, null);
}

3.3.2 unpark

/**
 * 如果尚未提供给定线程的许可，则使其可用。
 * 如果线程被park{@code park},调用unpark唤醒线程。 unpark将确保线程的下一次{@code park}可用。
 * 如果给定线程尚未启动，则不能保证此操作完全无效。
 *
 * @param thread 要唤醒的线程，如果为null,此操作无效
 */
public static void unpark(Thread thread) {
    if (thread != null)
        UNSAFE.unpark(thread); // 调用unsafe的unpark方法
}

4、扩展

4.1 UNSAFE.PARK 和 UNSAFE.UNPARK

UNSAFE.PARK 和 UNSAFE.UNPARK都是native方法，它们最终调用的是C++的park和unpark方法

• park/unpark能够精准的对线程进行唤醒和等待。
• linux上的实现是通过POSIX的线程API的等待、唤醒、互斥、条件来进行实现的
• park在执行过程中首选看是否有许可，有许可就立马返回，而每次unpark都会给许可设置成有，这意味着，可以先执行unpark，给予许可，再执行park

void Parker::park(bool isAbsolute, jlong time) {
  if (_counter > 0) {
       //已经有许可了，用掉当前许可
      _counter = 0 ;
     //使用内存屏障，确保 _counter赋值为0(写入操作)能够被内存屏障之后的读操作获取内存屏障事前的结果，也就是能够正确的读到0
      OrderAccess::fence();
     //立即返回
      return ;
  }

  Thread* thread = Thread::current();
  assert(thread->is_Java_thread(), "Must be JavaThread");
  JavaThread *jt = (JavaThread *)thread;

 if (Thread::is_interrupted(thread, false)) {
 // 线程执行了中断，返回
    return;
  }

  if (time < 0 || (isAbsolute && time == 0) ) { 
    //时间到了，或者是代表绝对时间，同时绝对时间是0（此时也是时间到了），直接返回，java中的parkUtil传的就是绝对时间，其它都不是
   return;
  }
  if (time > 0) {
  //传入了时间参数，将其存入absTime，并解析成absTime->tv_sec(秒)和absTime->tv_nsec(纳秒)存储起来，存的是绝对时间
    unpackTime(&absTime, isAbsolute, time);
  }

 //进入safepoint region，更改线程为阻塞状态
  ThreadBlockInVM tbivm(jt);

 if (Thread::is_interrupted(thread, false) || pthread_mutex_trylock(_mutex) != 0) {
  //如果线程被中断，或者是在尝试给互斥变量加锁的过程中，加锁失败，比如被其它线程锁住了，直接返回
    return;
  }
//这里表示线程互斥变量锁成功了
  int status ;
  if (_counter > 0)  {
    // 有许可了，返回
    _counter = 0;
    //对互斥变量解锁
    status = pthread_mutex_unlock(_mutex);
    assert (status == 0, "invariant") ;
    OrderAccess::fence();
    return;
  }

#ifdef ASSERT
  // Don't catch signals while blocked; let the running threads have the signals.  
// (This allows a debugger to break into the running thread.)  
 //debug用
sigset_t oldsigs;
  sigset_t* allowdebug_blocked = os::Linux::allowdebug_blocked_signals();
  pthread_sigmask(SIG_BLOCK, allowdebug_blocked, &oldsigs);
#endif
//将java线程所拥有的操作系统线程设置成 CONDVAR_WAIT状态 ，表示在等待某个条件的发生
OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */);
//将java的_suspend_equivalent参数设置为true
  jt->set_suspend_equivalent();
  // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self()
  if (time == 0) {
    //把调用线程放到等待条件的线程列表上，然后对互斥变量解锁，（这两是原子操作），这个时候线程进入等待，当它返回时，互斥变量再次被锁住。
  //成功返回0，否则返回错误编号
    status = pthread_cond_wait (_cond, _mutex) ;
  } else {
  //同pthread_cond_wait，只是多了一个超时，如果超时还没有条件出现，那么重新获取胡吃两然后返回错误码 ETIMEDOUT
    status = os::Linux::safe_cond_timedwait (_cond, _mutex, &absTime) ;
    if (status != 0 && WorkAroundNPTLTimedWaitHang) {
   //WorkAroundNPTLTimedWaitHang 是JVM的运行参数，默认为1
  //去除初始化
      pthread_cond_destroy (_cond) ;
//重新初始化
      pthread_cond_init    (_cond, NULL);
    }
  }
  assert_status(status == 0 || status == EINTR ||
                status == ETIME || status == ETIMEDOUT,
                status, "cond_timedwait");

#ifdef ASSERT
  pthread_sigmask(SIG_SETMASK, &oldsigs, NULL);
#endif
 //等待结束后，许可被消耗，改为0  _counter = 0 ;
//释放互斥量的锁
  status = pthread_mutex_unlock(_mutex) ;
  assert_status(status == 0, status, "invariant") ;
  // If externally suspended while waiting, re-suspend 
    if (jt->handle_special_suspend_equivalent_condition()) {
    jt->java_suspend_self();
  }
//加入内存屏障指令
  OrderAccess::fence();
}

void Parker::unpark() {
  int s, status ;
 //给互斥量加锁，如果互斥量已经上锁，则阻塞到互斥量被解锁
//park进入wait时，_mutex会被释放
  status = pthread_mutex_lock(_mutex);
  assert (status == 0, "invariant") ; 
  //存储旧的_counter
  s = _counter; 
//许可改为1，每次调用都设置成发放许可
  _counter = 1;
  if (s < 1) {
     //之前没有许可
     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 {
   //一直有许可，释放掉自己加的锁,有许可park本身就返回了
    pthread_mutex_unlock(_mutex);
    assert (status == 0, "invariant") ;
  }
}

4.2 Thread.sleep、Object.wait、LockSupport.park 区别

因为park能阻塞线程，所以想到wait, sleep这些，在网上找了下，有位博主总结的特别好：
这里直接用了他的图（来源在文末已注明）

4.2.1 使用wait阻塞线程

public class WaitAndNotifyDemo {
    
    static class MyThread extends Thread {
    

        public void run() {
    
            synchronized (this) {
    
                System.out.println("before notify");
                notify();
                System.out.println("after notify");
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
    
        MyThread myThread = new MyThread();
        // 调用wait时，当前线程必须持有对象锁（获取对象锁方式：synchronized），不然编译可以通过，但运行会抛出IllegalMonitorStateException。
        synchronized (myThread) {
    
            try {
    
                myThread.start();
                // 主线程睡眠3s
                Thread.sleep(3000);
                System.out.println("before wait");
                // 阻塞主线程
                myThread.wait();
                System.out.println("after wait");
            } catch (InterruptedException e) {
    
                e.printStackTrace();
            }
        }
    }
} 

输出

before wait
before notify
after notify
after wait

4.2.2 使用park阻塞线程

这里我们直接使用上面的FIFOMutex类

public class ParkDemo {
    private static FIFOMutex fifoMutex = new FIFOMutex();

    static class MyThread extends Thread {

        public void run() {
            try {
                Thread.sleep(3000L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("my thread");
            fifoMutex.unlock();
        }
    }
    public static void main(String[] args) throws InterruptedException {
        fifoMutex.lock();
        System.out.println("消耗一个许可");
        MyThread myThread = new MyThread();
        myThread.start();
        // park第一次调用，由于许可还在，所以能通过，第二次调park，许可没了，需要等unpark
        fifoMutex.lock();
        System.out.println("main thread");
    }
}

5、面试题解答

1. 为什么LockSupport也是核心基础类? AQS框架借助于两个类：Unsafe(提供CAS操作)和LockSupport(提供park/unpark操作)
2. LockSupport.park()会释放锁资源吗?
   不会，它只负责阻塞当前线程
3. 如果在wait()之前执行了notify()会怎样?
   抛异常IllegalMonitorStateException
4. 如果在park()之前执行了unpark()会怎样?
   park被通过，消耗一个许可

6、源码中文注释（全）

源码放重开一篇，因为一篇太长编辑有点卡…

https://blog.csdn.net/hhy107107/article/details/108173860

---

参考：

https://blog.csdn.net/u013332124/article/details/84647915

https://segmentfault.com/a/1190000008420938

https://blog.csdn.net/weixin_39687783/article/details/85058686

https://www.pdai.tech/md/java/thread/java-thread-x-lock-LockSupport.html