[关闭]
@kiraSally 2018-03-12T18:54:52.000000Z 字数 7336 阅读 3516

并发番@LockSupport一文通(1.8版)

JAVA 并发 源码 1.8版


1.LockSupport综述

  • 定义: LockSupport是一个线程阻塞工具类,可用于在线程内任意位置让线程阻塞和释放
  • 作用: LockSupport通常不会被直接使用,更多是作为锁实现的基础工具类
  • 实现: LockSupport底层依赖UnSafe实现,即park()和unpark()原语方法,通过"许可"替代状态
  • 使用: park方法用于线程等待"许可",unpark方法用于为线程提供"许可"
  • 补充1:由于"许可"的存在,当出现一个线程调用park方法,其他线程调用unpark方法时,会保持活跃
  • 补充2:若开JVM篇的话笔者会从JVM源码角度再次解析park和unpark的底层实现,其实质用mutex和condition维护一个_counter(park->0,unpark->1)的变量,即"许可"是一次性的
  • 补充3:此番为 并发番@AQS框架一文通(1.8版)(赶制中)的子番

2.LockSupport的数据结构

2.1 类定义

  1. public class LockSupport

2.2 构造器

  1. //私有构造器,不能被实例化 -- 实质就是个工作类,只能调用静态方法
  2. private LockSupport() {} // Cannot be instantiated.

2.3 UnSafe

  1. // Hotspot implementation via intrinsics API
  2. private static final sun.misc.Unsafe UNSAFE;
  3. //用于记录线程被谁阻塞的,用于线程监控和分析工具来定位原因,其表示parkBlocker在内存的偏移量
  4. //之所以用偏移量是因为parkBlockerOffset被赋值时线程必须是阻塞的,阻塞时直接调方法无效只能走内存
  5. private static final long parkBlockerOffset;
  6. private static final long SEED;
  7. private static final long PROBE;
  8. private static final long SECONDARY;
  9. static {
  10. try {
  11. UNSAFE = sun.misc.Unsafe.getUnsafe();
  12. Class<?> tk = Thread.class;
  13. //获取指定变量的内存偏移量
  14. parkBlockerOffset = UNSAFE.objectFieldOffset
  15. (tk.getDeclaredField("parkBlocker"));
  16. SEED = UNSAFE.objectFieldOffset
  17. (tk.getDeclaredField("threadLocalRandomSeed"));
  18. PROBE = UNSAFE.objectFieldOffset
  19. (tk.getDeclaredField("threadLocalRandomProbe"));
  20. SECONDARY = UNSAFE.objectFieldOffset
  21. (tk.getDeclaredField("threadLocalRandomSecondarySeed"));
  22. } catch (Exception ex) { throw new Error(ex); }
  23. }

2.4 permit(许可)

  • LockSupport和每个使用它的线程都与一个permit关联,某种意义上可认为是Semaphore类,但区别于Semaphores,permit至多只有一个,并不能被累加(即重复调动unpark也不会累加,最多为1)
  • permit相当于一个开关(只有0和1两个值),默认为0,执行过程如下:
    • 调用unpark方法,permit+1,即permit=1
    • 调用park方法,permit被消费-1,即permit=0,同时park方法理解返回
    • 再次调用park方法,线程会被阻塞(此时permit=0,线程无许可可用,直到permit=1之前都会被阻塞)

3 LockSupport重要方法

3.1 setBlocker方法

  1. /**
  2. * Returns the blocker object supplied to the most recent
  3. * invocation of a park method that has not yet unblocked, or null
  4. * if not blocked. The value returned is just a momentary
  5. * snapshot -- the thread may have since unblocked or blocked on a
  6. * different blocker object.
  7. * 返回提供给最近一次尚未解除阻塞的被park方法调用的blocker对象,如果该调用未阻塞,则返回null
  8. * @param t the thread
  9. * @return the blocker
  10. * @throws NullPointerException if argument is null
  11. * @since 1.6
  12. */
  13. public static Object getBlocker(Thread t) {
  14. if (t == null)
  15. throw new NullPointerException();
  16. return UNSAFE.getObjectVolatile(t, parkBlockerOffset);
  17. }
  18. /**
  19. * This object is recorded while the thread is blocked to permit monitoring and diagnostic
  20. * tools to identify the reasons that threads are blocked.
  21. * 此对象在线程受阻塞时被记录,以允许监视工具和诊断工具确定线程受阻塞的原因
  22. */
  23. private static void setBlocker(Thread t, Object arg) {
  24. // Even though volatile, hotspot doesn't need a write barrier here.
  25. UNSAFE.putObject(t, parkBlockerOffset, arg);
  26. }
  1. public static void main(String[] args) {
  2. new Thread(() -> LockSupport.park(),"sally").start();
  3. new Thread(() -> LockSupport.park(LockSupport.getBlocker(Thread.currentThread())),"kira").start();
  4. while (true);
  5. }

Dump.png-14.4kB

3.2 park方法

  • 作用:该方法用于等待"许可",调用时可能发生以下两种情况:
    • 当"许可"可用时,立即返回并且消费这个许可(将许可变成不可用)
    • 当"许可"不可用时,当前线程可能被阻塞 java.lang.Thread.State : WAITING parking
  • 使用: 由于park方法可能在任何时候"无理由"返回,因此通常会在循环中使用(在返回之前再次检查条件)
  • 适用: park方法是"busy wait"(忙碌等待)的一种优化(即不需要在自旋上浪费太多时间),但它必须与unpark配对使用才更高效
  • 注意: park方法的许可默认是被占用的,在unpark之前调用会获取不到许可而被阻塞
  1. public static void park() {
  2. UNSAFE.park(false, 0L);
  3. }
  4. //纳秒级超时返回
  5. public static void parkNanos(long nanos) {
  6. if (nanos > 0)
  7. UNSAFE.park(false, nanos);
  8. }
  9. //毫秒级限时等待
  10. //注意这里的时间需要使用系统时间加上需要等待的时间
  11. //LockSupport.parkUntil(System.currentTimeMillis() + 3000);
  12. public static void parkUntil(long deadline) {
  13. UNSAFE.park(true, deadline);
  14. }
  15. //三种形式的 park 还各自支持一个 blocker 对象参数
  16. //建议最好使用这些形式,而不是不带此参数的原始形式
  17. //在锁实现中提供的作为 blocker 的普通参数是 this
  18. public static void park(Object blocker) {
  19. Thread t = Thread.currentThread();
  20. setBlocker(t, blocker);
  21. UNSAFE.park(false, 0L);
  22. setBlocker(t, null);
  23. }
  24. public static void parkNanos(Object blocker, long nanos) {
  25. if (nanos > 0) {
  26. Thread t = Thread.currentThread();
  27. setBlocker(t, blocker);
  28. UNSAFE.park(false, nanos);
  29. setBlocker(t, null);
  30. }
  31. }
  32. public static void parkUntil(Object blocker, long deadline) {
  33. Thread t = Thread.currentThread();
  34. setBlocker(t, blocker);
  35. UNSAFE.park(true, deadline);
  36. setBlocker(t, null);
  37. }

3.3 unpark方法

  • 作用: 该方法用于提供"许可",会将还不可用的"许可"变成可用
  • 注意: 由于park方法默认是许可占有并阻塞线程,因此调用park之前最好先调用unpark(当然因为park\unpark的顺序解耦性,所以前后执行顺序无所谓,只是代码上最好遵循 先释放再获取 的规则)
  1. /**
  2. * 注意:必须指定一个线程(但无所谓该线程是否park),将尝试释放其可能拥有的许可
  3. */
  4. public static void unpark(Thread thread) {
  5. if (thread != null)
  6. UNSAFE.unpark(thread);
  7. }

4.LockSupport不可重入

  • 不可重入: LockSupport不可重入,当一个线程多次调用park方法,线程将被第二个park方法阻塞
  1. public static void main(String[] args) {
  2. LockSupport.unpark(Thread.currentThread());//我们直接用主线程
  3. System.out.println("执行unpark");
  4. LockSupport.park();
  5. System.out.println("执行第一次park");
  6. LockSupport.park();
  7. System.out.println("执行第二次park");
  8. while (true);
  9. }
  10. ---------------------
  11. //输出:
  12. 执行unpark
  13. 执行第一次park
  14. //分析:通过打印结果可以发现第7行其实并没有被打印,根据下面的图片可以看到线程在第7行(对应图片的第16行)上阻塞

LockSupport不可重入.png-5.3kB

5.LockSupport与中断

  • 中断响应: LockSupport支持中断响应,线程调用park阻塞时仍能够响应中断请求,但不会抛出InterruptedException异常
  1. public static void main(String[] args) {
  2. Thread thread = new Thread(() -> {
  3. long start = System.currentTimeMillis();
  4. while ((System.currentTimeMillis() - start) <= 1000);//空转1s
  5. System.out.println("空转1s结束");
  6. LockSupport.park();//等待"许可"
  7. System.out.println(Thread.currentThread().getName() + "是否被中断:"
  8. + Thread.currentThread().isInterrupted());
  9. },"kira");
  10. thread.start();
  11. thread.interrupt();//中断线程
  12. }
  13. ---------------------
  14. //输出:
  15. 空转1s结束
  16. kira是否被中断:true
  17. //分析:通过先中断线程再park可以发现可获取中断响应,同时并没有抛出任何异常

6. suspend() vs wait() vs park()

6.1 suspend() vs wait()

  • suspend()不会释放锁,wait()会释放锁同时还支持超时处理

6.2 park() vs suspend()

  • LockSupport解决了suspend()不释放锁从而容易死锁的问题,比如resume()方法被阻塞时,即其他线程在调用resume()方法之前获取同步锁时被阻塞而导致resume()方法无法执行进而导致死锁

6.3 park() vs wait()

  • LockSupport不需要先获得某个对象的锁,也不会排除InterruptedException异常
  • unpark方法可以先于park方法调用,其没有方法调用的时序问题
  • wait/notify机制有个问题在于线程调用notify方法去唤醒其他线程时,需要保证需被唤醒线程必须被wait方法阻塞,否则被唤醒线程会永远处于WAITING状态,同时notify方法只能唤醒一个线程,当同时有多个线程在同一个对象上wait等待,就只能有一个线程可以被唤醒(不能指定)
  • park/unpark机制通过引入单个"许可"的概念实现对线程同步的解耦,线程间无须关心对方的状态,因为不需要一个变量专门用于存储状态

7.LockSupport官方标准用法

7.1 标准用法

  1. //官方提供的标准用法
  2. while (!canProceed()) { ... LockSupport.park(this); }}

7.2 FIFOMutex

  1. /**
  2. * Here is a sketch of a first-in-first-out non-reentrant lock class:
  3. * 官方提供了一个FIFO先进先出的非重入锁实现Demo
  4. */
  5. class FIFOMutex {
  6. private final AtomicBoolean locked = new AtomicBoolean(false);//锁标记
  7. private final Queue<Thread> waiters
  8. = new ConcurrentLinkedQueue<Thread>();//无界线程安全队列,存放等待线程
  9. public void lock() {
  10. boolean wasInterrupted = false;//标记中断
  11. Thread current = Thread.currentThread();
  12. waiters.add(current);//添加当前线程到队尾(FIFO)
  13. // Block while not first in queue or cannot acquire lock
  14. //阻塞条件:当前线程非队列首元素(FIFO) or 没有获得锁
  15. while (waiters.peek() != current ||
  16. !locked.compareAndSet(false, true)) {
  17. LockSupport.park(this);
  18. //补充一点:调用interrupted方法会将线程真正的中断状态清除,连续调用会返回false
  19. //这里的作用主要用于在park调用时线程阻塞过程中忽略中断带来的其他影响
  20. if (Thread.interrupted()) // ignore interrupts while waiting
  21. wasInterrupted = true;//当前线程若被中断,需要重新标记中断状态
  22. }
  23. //当能够获取锁后,将首元素移除(FIFO),立即返回
  24. waiters.remove();
  25. if (wasInterrupted) // reassert interrupt status on exit
  26. current.interrupt();//若线程被标记为中断,需要重新声明为中断状态
  27. }
  28. public void unlock() {
  29. locked.set(false);//解锁
  30. LockSupport.unpark(waiters.peek());//解除队列首元素的阻塞,FIFO
  31. }
  32. }

8.LockSupport vs Object

这里主要是对比 LockSuppor.park/unpark()object.wait/notify() 的区别:
面向对象不同:前者能够主动指定Thread;后者必须被动执行且不能准确指定,具有随机性
监视器是否必须:前者由于只需要"许可",因此无需监视器;后者能使用的前提是必须获取监视器,即wait/notify()必须出现在synchronized作用范围内
实现机制不同:前者使用的是"许可",后者使用的监视器,两者无交集,互相不会影响

并发番@LockSupport一文通(1.8版)黄志鹏kira 创作,采用 知识共享 署名-非商业性使用 4.0 国际 许可协议 进行许可。

本站文章除注明转载/出处外,均为本站原创或翻译,转载前请务必署名

添加新批注
在作者公开此批注前,只有你和作者可见。
回复批注