LockSupport 是什么？怎么用？

前言

本文隶属于专栏《100个问题搞定Java并发》，该专栏为笔者原创，引用请注明来源，不足和错误之处请在评论区帮忙指出，谢谢！

本专栏目录结构和参考文献请见100个问题搞定Java并发

正文

LockSupport 是一个非常方便实用的线程阻塞工具，它可以在线程内任意位置让线程阻塞。

与 Thread.suspend() 方法相比，它弥补了由于 resume() 方法发生导致线程无法继续执行的情况。

关于 suspend 和 resume 请参考我的博客——线程的挂起(suspend)和继续执行(resume)是什么情况？

和 Object.wait() 方法相比，它不需要先获得某个对象的锁，也不会抛出 InterruptedException 异常

关于 wait 请参考我的博客——线程的等待(wait)和通知(notify)是什么情况？

LockSupport 的静态方法 park() 可以阻塞当前线程，类似的还有 parkNanos() 、 parkUntil() 等方法。

它们实现了一个限时的等待。

对比

为了更好的将 LockSupport 和 suspend 进行对比，这里我们举一个例子。

suspend

下面的代码中 suspend 方法将导致线程卡死。

package com.shockang.study.java.concurrent.thread.suspend;

public class SuspendDemo {
	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.setName(name);
		}
		@Override
		public void run() {
			synchronized (u) {
				System.out.println("in "+getName());
				Thread.currentThread().suspend();
			}
		}
	}

	public static void main(String[] args) throws InterruptedException {
		t1.start();
		Thread.sleep(100);
		t2.start();
		t1.resume();
		t2.resume();
		t1.join();
		t2.join();
	}
}

LockSupport

现在用 LockSupport 重写这个程序:

package com.shockang.study.java.concurrent.lock;

import java.util.concurrent.locks.LockSupport;

public class LockSupportDemo {
    private 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.setName(name);
        }

        @Override
        public void run() {
            synchronized (u) {
                System.out.println("in " + getName());
                LockSupport.park();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        t1.start();
        Thread.sleep(100);
        t2.start();
        LockSupport.unpark(t1);
        LockSupport.unpark(t2);
        t1.join();
        t2.join();
    }
}

注意，这里只是将原来的 suspend 方法和 resume() 方法用 park() 方法和 unpark() 方法做了替换。

当然，我们依然无法保证 unpark() 方法发生在 park() 方法之后。

但是执行这段代码，你会发现，它自始至终都可以正常地结束，不会因为 park() 方法而导致线程水久挂起。

这是因为 LockSupport 类使用类似信号量的机制。

它为每一个线程准备了一个许可，如果许可可用，那么 park() 方法会立即返回，并且消费这个许可(也就是将许可变为不可用)。

如果许可不可用，就会阻塞，而 unpack 方法则使得一个许可变为可用(但是和信号量不同的是，许可不能累加，你不可能拥有超过一个许可，它永远只有一个)。

这个特点使得:即使 unpack() 方法操作发生在 park() 方法之前，它也可以使下一次的 park() 方法操作立即返回。

这也就是上述代码可顺利结束的主要原因。

线程状态 WAITING (parking)

同时，处于 parko 方法挂起状态的线程不会像 suspend 方法那样还给出一个令人费解的 Runnable 状态。

它会非常明确地给出一个 WAITING 状态，甚至还会标注是 park() 方法引起的。

这使得分析问题时格外方便。

"t1" #8 prio=5 os_prio=0 tid=0x00b1a400 nid=0x1994 waiting on condition [0x1619f000]
    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.shockang.study.java.concurrent.lock.LockSupportDemo$ChangeObjectThread.run(LockSupportDemo.java: 19) 
        - locked <0x048b2680> (a java.lang.Object)

此外，如果你使用 park(Object)函数，那么还可以为当前线程设置一个阻塞对象。

这个阻塞对象会出现在线程 Dump 中。

这样在分析问题时，就更加方便了。

比如，我们将上述代码第 14 行的 park() 方法改为

LockSupport.park(this);

那么在线程 Dump 时，你可能会看到如下信息:

"t1" #8 prio=5 os_prio=0 tid=0x0117ac00 nid=0x2034 waiting on condition [0x15d0f000]
    java.lang.Thread.State: WAITING (parking) 
        at sun.misc.Unsafe.park(Native Method) 
        - parking to wait for <0x048b4738> (a com.shockang.study.java.concurrent.lock.LockSupportDemo$ChangeObjectThrea)
        at java.util..concurrent.locks..LockSupport.park(LockSupport.java: 304) 
        at com.shockang.study.java.concurrent.lock.LockSupportDemo$ChangeObjectThread.run(LockSupportDemo.java: 19) 
        - locked <0x048b2808> (a java.lang.Object)

注意，在堆栈中，我们甚至还看到了当前线程等待的对象，这里就是 ChangeObjectThread 实例

支持中断

除了有定时阻塞的功能， LockSupport.park() 方法还能支持中断影响。

但是和其他接收中断的函数很不一样， LockSupport.park() 方法不会抛出 InterruptedException 异常。

它只会默默返回，但是我们可以从 Thread.interrupted() 等方法中获得中断标记。

代码

package com.shockang.study.java.concurrent.lock;

import java.util.concurrent.locks.LockSupport;

public class LockSupportIntDemo {
    private 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.setName(name);
        }

        @Override
        public void run() {
            synchronized (u) {
                System.out.println("in " + getName());
                LockSupport.park();
                if (Thread.interrupted()) {
                    System.out.println(getName() + " 被中断了");
                }
            }
            System.out.println(getName() + "执行结束");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        t1.start();
        Thread.sleep(100);
        t2.start();
        t1.interrupt();
        LockSupport.unpark(t2);
    }
}

控制台

in t1
t1 被中断了
t1执行结束
in t2
t2执行结束