一. 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<Thread> waiters = new ConcurrentLinkedQueue<Thread>();
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状态多了一种唤醒方式，就是超过规定时间，那么线程会自动醒来。
