LockSupport.park 与wait用法示例

自Java1.6引入的LockSupport为开发者提供新的阻塞、唤醒线程的原语方法，只是平时都是使用已经封装好的各种Lock、Latch、Synchronizer并不常见到。在学习过程中看到这篇对比LockSupport.park() 方法和wait() 方法的示例Java多线程系列–“JUC锁”07之 LockSupport 来自skywang12345是的引起自己诸多疑惑，便打算按照编码实践一番。

在这就直接绕过基本介绍，详细实现可参考 https://my.oschina.net/readjava/blog/282882

LockSupport 函数列表

// 返回提供给最近一次尚未解除阻塞的 park 方法调用的 blocker 对象，如果该调用不受阻塞，则返回 null。
static Object getBlocker(Thread t)
// 为了线程调度，禁用当前线程，除非许可可用。
static void park()
// 为了线程调度，在许可可用之前禁用当前线程。
static void park(Object blocker)
// 为了线程调度禁用当前线程，最多等待指定的等待时间，除非许可可用。
static void parkNanos(long nanos)
// 为了线程调度，在许可可用前禁用当前线程，并最多等待指定的等待时间。
static void parkNanos(Object blocker, long nanos)
// 为了线程调度，在指定的时限前禁用当前线程，除非许可可用。
static void parkUntil(long deadline)
// 为了线程调度，在指定的时限前禁用当前线程，除非许可可用。
static void parkUntil(Object blocker, long deadline)
// 如果给定线程的许可尚不可用，则使其可用。
static void unpark(Thread thread)

Object.wait() 阻塞示例

public class WaitTest {
    public static void main(String[] args) {
        ThreadA ta = new ThreadA("ta");
        synchronized(ta) { // 通过synchronized(ta)获取“对象ta的同步锁”
            try {
                System.out.println(Thread.currentThread().getName()+" start ta");
                ta.start();//断点一
                System.out.println("Do something before "+Thread.currentThread().getName()+"block");
                for (int i=0;i<Integer.MAX_VALUE;i++) ;
                System.out.println(Thread.currentThread().getName()+" block");
                // 主线程等待
                ta.wait();//断点二
                System.out.println(Thread.currentThread().getName()+" continue");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    static class ThreadA extends Thread{
        public ThreadA(String name) {
            super(name);
        }
        public void run() {
            synchronized (this) { // 通过synchronized(this)获取“当前对象的同步锁”
                System.out.println(Thread.currentThread().getName()+" wakup others");//断点三
                notify();    // 唤醒“当前对象上的等待线程”
                System.out.println("After wakup");//断点四
            }
        }
    }
}

输出：

main start ta
Do something before mainblock
main block
ta wakup others
After wakup
main continue

断点经历过程顺序：

线程名	断点一	断点二	断点三	断点四
main	RUNNING	RUNNING	WAIT	MONITOR
ta	未创建	MONITOR	RUNNING	RUNNING

断点二开始：

ta 线程 MONITOR 状态表示线程处于 synchronized (this)，正在等待main 线程释放 ta 对象的锁（monitor）

main 线程中调用 ta.wait() 释放对象 ta 的锁，并进入WAIT 状态，ta 线程获取到锁后进入 RUNNING状态

ta 线程中调用 notify() 唤醒一个调用自身对象 ta.wait() 方法的线程，于是 main 线程状态从WAIT到MONITOR

LockSupport.park() 阻塞示例

import java.util.concurrent.locks.LockSupport;
public class LockSupportTest1 {
    private static Thread mainThread;
    public static void main(String[] args) {
        ThreadA ta = new ThreadA("ta");
        // 获取主线程
        mainThread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName()+" start ta");
        ta.start();//断点一
        System.out.println(Thread.currentThread().getName()+" block");
        // 主线程阻塞
        LockSupport.park(Thread.currentThread());//断点二
        System.out.println(Thread.currentThread().getName()+" continue");
    }
    static class ThreadA extends Thread{
        public ThreadA(String name) {
            super(name);
        }
        public void run() {
            System.out.println(Thread.currentThread().getName()+" wakup others");//断点三
            // 唤醒“主线程”
            LockSupport.unpark(mainThread);
            System.out.println("After wakup others");//断点四
        }
    }
}

断点顺序很可能是一 -> 三 -> 四 -> 二或者一 -> 三 ->二等等，单是线程都不会出现 MONITOR 状态

所有输出的情况也有多种情况，甚至会出现先执行unpark 后执行 park 当时依然可以输出 main continue

总结

1、wait 是通过线程对对象的锁的占用、释放来间接实现阻塞、和唤醒的，并且调用对象的wait 方法必须要拥有此对象的锁。而 park 则实现线程阻塞机制却不同，不需要对对象的锁进行操作。

2、若通过wait 方法调用来实现线程间阻塞、唤醒的配合的话，需要考虑好wait 和 notify、notifyAll 的配合顺序，不然可能出现先执行notify 后执行notify 导致线程一直处于WAIT 状态。而通过park 和 unpark 实现线程间的配合则不需要考虑这些，即使 unpark 先执行不会阻塞线程，后执行 park 也不会阻塞线程。这是因为实现上 park 和 unpark 是通过对被称为许可证的数值进行增减操作，通过对此许可证值的判断来进行阻塞、唤醒操作的。