LockSupport
LockSupport
是一个线程阻塞工具类,所有的方法都是静态方法,可以让线程在任意位置阻塞,当然阻塞之后肯定得有唤醒的方法。主要有两类方法:park
和unpark
。
public static void park(Object blocker); // 暂停当前线程 public static void parkNanos(Object blocker, long nanos); // 暂停当前线程,不过有超时时间的限制 public static void parkUntil(Object blocker, long deadline); // 暂停当前线程,直到某个时间 public static void park(); // 无期限暂停当前线程 public static void parkNanos(long nanos); // 暂停当前线程,不过有超时时间的限制 public static void parkUntil(long deadline); // 暂停当前线程,直到某个时间 public static void unpark(Thread thread); // 恢复当前线程 public static Object getBlocker(Thread t);
为什么叫park呢,park英文意思为停车。我们如果把Thread看成一辆车的话,park就是让车停下,unpark就是让车启动然后跑起来。
每个线程都有一个许可(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源码注释
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); } } }
我们写一个例子来看看这个工具类怎么用的。
public class LockSupportDemo { public static Object u = new Object(); static ChangeObjectThread t1 = new ChangeObjectThread("t1"); static ChangeObjectThread t2 = new ChangeObjectThread("t2"); public static class ChangeObjectThread extends Thread { public ChangeObjectThread(String name) { super(name); } @Override public void run() { synchronized (u) { System.out.println("in " + getName()); LockSupport.park(); if (Thread.currentThread().isInterrupted()) { System.out.println("被中断了"); } System.out.println("继续执行"); } } } public static void main(String[] args) throws InterruptedException { t1.start(); Thread.sleep(1000L); t2.start(); Thread.sleep(3000L); t1.interrupt(); LockSupport.unpark(t2); t1.join(); t2.join(); } }
运行的结果如下:
in t1
被中断了
继续执行
in t2
继续执行
这儿park
和unpark
其实实现了wait
和notify
的功能,不过还是有一些差别的。
park
不需要获取某个对象的锁- 因为中断的时候
park
不会抛出InterruptedException
异常,所以需要在park
之后自行判断中断状态,然后做额外的处理。
park系列方法线程进入两种状态:WAITING等待状态或TIMED_WAITING等待状态。这两种状态都会使线程阻塞在当前位置。
那么怎么唤醒这两种状态的线程呢?
对于WAITING等待状态有两种唤醒方式:
- 调用对应的唤醒方法。这里就是LockSupport的unpark方法。
- 调用该线程变量的interrupt()方法,会唤醒该线程,并抛出InterruptedException异常。
对于TIMED_WAITING等待状态来说,它比WAITING状态多了一种唤醒方式,就是超过规定时间,那么线程会自动醒来。
我们再来看看Object blocker
,这是个什么东西呢?这其实就是方便在线程dump的时候看到具体的阻塞对象的信息
"t1" #10 prio=5 os_prio=31 tid=0x00007f95030cc800 nid=0x4e03 waiting on condition [0x00007000011c9000] java.lang.Thread.State: WAITING (parking) at sun.misc.Unsafe.park(Native Method) at java.util.concurrent.locks.LockSupport.park(LockSupport.java:304) // `下面的这个信息` at com.wtuoblist.beyond.concurrent.demo.chapter3.LockSupportDemo$ChangeObjectThread.run(LockSupportDemo.java:23) // - locked <0x0000000795830950> (a java.lang.Object)
还有一个地方需要注意,相对于线程的stop和resume
,park和unpark
的先后顺序并不是那么严格。stop和resume
如果顺序反了,会出现死锁现象。而park和unpark
却不会。这又是为什么呢?还是看一个例子
public class LockSupportDemo { public static Object u = new Object(); static ChangeObjectThread t1 = new ChangeObjectThread("t1"); public static class ChangeObjectThread extends Thread { public ChangeObjectThread(String name) { super(name); } @Override public void run() { synchronized (u) { System.out.println("in " + getName()); try { Thread.sleep(1000L); } catch (InterruptedException e) { e.printStackTrace(); } LockSupport.park(); if (Thread.currentThread().isInterrupted()) { System.out.println("被中断了"); } System.out.println("继续执行"); } } } public static void main(String[] args) { t1.start(); LockSupport.unpark(t1); System.out.println("unpark invoked"); } }
t1内部有休眠1s的操作,所以unpark肯定先于park的调用,但是t1最终仍然可以完结。这是因为park和unpark
会对每个线程维持一个许可(boolean值)
- unpark调用时,如果当前线程还未进入park,则许可为true
- park调用时,判断许可是否为true,如果是true,则继续往下执行;如果是false,则等待,直到许可为true
我们再看看jdk的文档描述
![](https://img2018.cnblogs.com/blog/1445502/201908/1445502-20190829141454856-751352165.png)
总结一下
1.park和unpark
可以实现类似wait和notify
的功能,但是并不和wait和notify
交叉,也就是说unpark
不会对wait
起作用,notify
也不会对park
起作用。
2.park和unpark
的使用不会出现死锁的情况
3.blocker的作用是在dump线程的时候看到阻塞对象的信息。
https://www.cnblogs.com/heyq/p/9013783.html
线程阻塞与唤醒
方式1:早期JAVA采用suspend()、resume()对线程进行阻塞与唤醒,但这种方式产生死锁的风险很大,因为线程被挂起以后不会释放锁,可能与其他线程、主线程产生死锁.
方式2:wait、notify形式通过一个object作为信号,object的wait()方法是锁门的动作,notify()、notifyAll()是开门的动作,某一线程一旦关上门后其他线程都将阻塞,直到别的线程打开门。notify()准许阻塞的一个线程通过,notifyAll()允许所有线程通过。如下例子:主线程分别启动两个线程,随后通知子线程暂停等待,再逐个唤醒后线程抛异常退出。
wait、notify使用要点:
1、对象操作都需要加同步synchronized;
2、线程需要阻塞的地方调用对象的wait方法;
存在的不足:面向对象的阻塞是阻塞当前线程,而唤醒的是随机的一个线程或者所有线程,偏重线程间的通信;同时某一线程在被另一线程notify之前必须要保证此线程已经执行到wait等待点,错过notify则可能永远都在等待。
方式3:LockSupport提供的park和unpark方法,提供避免死锁和竞态条件,很好地代替suspend和resume组合。
park与unpark方法控制的颗粒度更加细小,能准确决定线程在某个点停止,进而避免死锁的产生。
park与unpark引入了许可机制,许可逻辑为:
①park将许可在等于0的时候阻塞,等于1的时候返回并将许可减为0;
②unpark尝试唤醒线程,许可加1。根据这两个逻辑,对于同一条线程,park与unpark先后操作的顺序似乎并不影响程序正确地执行,假如先执行unpark操作,许可则为1,之后再执行park操作,此时因为许可等于1直接返回往下执行,并不执行阻塞操作。
park与unpark组合真正解耦了线程之间的同步,不再需要另外的对象变量存储状态,并且也不需要考虑同步锁,wait与notify要保证必须有锁才能执行,而且执行notify操作释放锁后还要将当前线程扔进该对象锁的等待队列,LockSupport则完全不用考虑对象、锁、等待队列等问题。
总结:suspend()、resume()已经被deprecated,不建议使用。wait、notify需要对对象加同步,性能有折扣。LockSupport则完全不用考虑对象、锁、等待队列。
链接:https://www.jianshu.com/p/f1f2cd289205