LockSupport详解
LockSupport详解
- 测试没有unpark，park会一直阻塞，unpark只是设置一个标识（ 许可没有是被占用的），而park查看标识，有继续执行，没有一直阻塞
// LockSupport.unpark(Thread.currentThread());
LockSupport.park();
// 如果不调用unpark线程会一直处于等待状态
System.out.println("block.");
- LockSupport是可不重入的，可以这样理解unpark，把flag改为1，执行park就看是否是1，是1继续执行并把flag设置为0，不是1阻塞（flag不存在，只是你让好理解）
Thread thread = Thread.currentThread();
LockSupport.unpark(thread);
System.out.println("a");
LockSupport.park();
System.out.println("b");
new Thread(new Runnable() {
@Override
public void run() {
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
LockSupport.unpark(thread);
}
},"allen").start();
LockSupport.park(); //如果线程allen，执行了unpark，"c"永远不会打印
System.out.println("c");
- 能够响应中断请求，但不抛异常，会使阻塞状态变成运行状态
Thread t = new Thread(() -> {
LockSupport.park(); //等待或许许可
System.out.println("thread over." + Thread.currentThread().isInterrupted());
});
t.start();
// 让线程执行到 LockSupport.park();
Thread.sleep(2000);
t.interrupt(); // 中断线程
System.out.println("main线程最后一条语句");
源码：底层实现是Unsafe，想看更深层，学习c、c++
package java.util.concurrent.locks;
import sun.misc.Unsafe;
public class LockSupport {
private LockSupport() {} // 不能实例化
private static final sun.misc.Unsafe UNSAFE;// Hotspot 内部实现
private static final long parkBlockerOffset;
private static final long SEED;
private static final long PROBE;
private static final long SECONDARY;
static {
try {
UNSAFE = sun.misc.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); }
}
private static void setBlocker(Thread t, Object arg) {
// Even though volatile, hotspot doesn't need a write barrier here.
UNSAFE.putObject(t, parkBlockerOffset, arg);
}
public static void unpark(Thread thread) {
if (thread != null) UNSAFE.unpark(thread);
}
public static void park(Object blocker) {
Thread t = Thread.currentThread();
setBlocker(t, blocker);
UNSAFE.park(false, 0L);
setBlocker(t, null);
}
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);
}
}
public static void parkUntil(Object blocker, long deadline) {
Thread t = Thread.currentThread();
setBlocker(t, blocker);
UNSAFE.park(true, deadline);
setBlocker(t, null);
}
public static Object getBlocker(Thread t) {
if (t == null) throw new NullPointerException();
return UNSAFE.getObjectVolatile(t, parkBlockerOffset);
}
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 = java.util.concurrent.ThreadLocalRandom.current().nextInt()) == 0)
r = 1; // avoid zero
UNSAFE.putInt(t, SECONDARY, r);
return r;
}
}