【JUC基础】09. LockSupport

奋斗吧

擅长邻域：未填写

标签：【JUC基础】09. LockSupport Html/CSS博客 51CTO博客

2023-05-28 18:24:04 71浏览

【JUC基础】09. LockSupport，LockSupport是一个线程阻塞工具，可以在线程任意位置让线程阻塞。线程操作阻塞的方式其实还有Thread.suspend()和Object.wait()。而LockSupport与suspend()相比，弥补了由于resume()方法而导致线程被挂起（类似死锁）的问题，也弥补了wait()需要先获得某个对象锁的问题，也不会抛出InterruptedException异常。

1、什么是LockSupport

LockSupport是一个线程阻塞工具，可以在线程任意位置让线程阻塞。线程操作阻塞的方式其实还有Thread.suspend()和Object.wait()。而LockSupport与suspend()相比，弥补了由于resume()方法而导致线程被挂起（类似死锁）的问题，也弥补了wait()需要先获得某个对象锁的问题，也不会抛出InterruptedException异常。

【JUC基础】09. LockSupport_线程阻塞

2、suspend()和resume()

说到线程阻塞，除了Object.wait()和Object.notify()两种以外，还有Thread.suspend()和Thread.resume()。不过当前这两组API已被弃用，因为他们可能会导致死锁情况发生。

【JUC基础】09. LockSupport_jvm_03

【JUC基础】09. LockSupport_System_04

示例代码：

package locksupport;

import java.util.concurrent.TimeUnit;

/**
 * @author Shamee loop
 * @date 2023/5/19
 */
public class ThreadSuspendTest {

    static Object syncObject = new Object();
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            synchronized (syncObject) {
                System.out.println(Thread.currentThread().getName() + "执行中，准备挂起");

                // 线程挂起
                Thread.currentThread().suspend();
            }
        }, "Thread-1");


        Thread thread2 = new Thread(() -> {
            synchronized (syncObject) {
                System.out.println(Thread.currentThread().getName() + "执行中，准备挂起");
                // 线程挂起
                Thread.currentThread().suspend();
            }
        }, "Thread-2");

        thread1.start();
        TimeUnit.SECONDS.sleep(1);
        thread2.start();
        // 继续执行
//        System.out.println("thread1线程准备执行了resume");
        thread1.resume();
//        System.out.println("thread1线程执行了resume");
        // 继续执行
//        System.out.println("thread2线程准备执行了resume");
        thread2.resume();
//        System.out.println("thread2线程执行了resume");
        thread1.join();
        thread2.join();
        System.out.println("程序运行结束");

    }
}

这里模拟了两个线程，运行过程中suspend()挂起，然后使用resume()让线程继续执行。

运行结果：

【JUC基础】09. LockSupport_System_05

可以看到程序无法退出，也无法打印“程序运行结束”日志。这就说明程序被永远挂起。原因是suspend()在导致线程暂停的同时，不会释放任何资源。此时其他线程想要访问被占用的锁时，都会导致阻塞。直到线程上进行了resume()，被挂起的线程才能继续。但是如果resume()方法操作以外的在suspend()之前进行了，那么被挂起的资源就尽可能永远被挂起而无法继续。

这里更加注意的时候，这时候被挂起的线程，状态还是Runnable，这些估计也是JDK不推荐的原因吧。

我们将上面几行注释的代码打开，在运行以下：

【JUC基础】09. LockSupport_System_06

我们发现thread2的resume()方法在suspend()之前就进行了。因此也解释了为什么thread2没有被继续执行的原因。

3、park()和unpark()

官方文档说了，LockSupport有两个重要的方法，park()和unpark()。而这两个方法很好的弥补了suspend()和resume()的不足。我们上述同等代码，用LockSupport来试下。

package locksupport;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;

/**
 * @author Shamee loop
 * @date 2023/5/19
 */
public class LockSupportTest {

    static Object syncObject = new Object();
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            synchronized (syncObject) {
                System.out.println(Thread.currentThread().getName() + "执行中，准备挂起");
                LockSupport.park();
            }
        }, "Thread-1");


        Thread thread2 = new Thread(() -> {
            synchronized (syncObject) {
                System.out.println(Thread.currentThread().getName() + "执行中，准备挂起");
                LockSupport.park();
            }
        }, "Thread-2");

        thread1.start();
        TimeUnit.SECONDS.sleep(1);
        thread2.start();

        // 继续执行
//        System.out.println("thread1线程准备执行了unpark");
        LockSupport.unpark(thread1);
//        System.out.println("thread1线程执行了unpark");
        // 继续执行
//        System.out.println("thread2线程准备执行了unpark");
        LockSupport.unpark(thread2);
//        System.out.println("thread2线程执行了unpark");

        thread1.join();
        thread2.join();
        System.out.println("程序运行结束");
    }
}

运行结果：

【JUC基础】09. LockSupport_线程阻塞_07

可以看到程序正常退出，也打印出“程序运行结束”日志。而代码中只是将原本的suspend()方法替换成LockSupport.park()，将thread1.resume()替换成LockSupport.unpark(thread1)。

这是因为LockSupport使用的是类似信号量的机制。他为每个线程准备了一个许可，如果许可可用，那么park()方法会立刻返回，并且消费这个许可（也就是将许可变成不可用）。如果许可不可用，就会阻塞，而unpark()则是使得一个许可变成可用，但是和信号量不同的时，许可不能累加，不可能拥有超过一个许可。

所以这个特点就使得，即使unpark()方法执行发生在park()之前，他也可以是下一次的park()方法立即返回（因为当前的许可是可用的）。

不仅如此，通常使用park()挂起的状态，不会像suspend()还是Runnabele，他会直接给出waiting状态，同时堆栈也会体现由于park()方法引起，因此相比suspend()来说也更加友好。

我们将上述代码的注释打开，看下运行结果：

【JUC基础】09. LockSupport_jvm_08

可以看到，thread2的unpark()就算运行在了park()之前，程序依然正常运行结束。

4、中断影响

LockSupport方法还支持中断影响。但是他的中断并不是直接抛出InterruptedException，而是默默返回，我们可以从Thread.interrupted方法中获得中断标记。

如代码：

package locksupport;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;

/**
 * @author Shamee loop
 * @date 2023/5/19
 */
public class LockSupportTest {

    static Object syncObject = new Object();
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(LockSupportTest::doExecuteOn, "Thread-1");
        Thread thread2 = new Thread(LockSupportTest::doExecuteOn, "Thread-2");

        thread1.start();
        TimeUnit.SECONDS.sleep(1);
        thread2.start();

        thread1.interrupt();
        LockSupport.unpark(thread2);

    }

    private static void doExecuteOn(){
        synchronized (syncObject) {
            System.out.println(Thread.currentThread().getName() + "执行中，准备挂起");
            LockSupport.park();
            if(Thread.interrupted()){
                System.out.println(Thread.currentThread().getName() + "中断了");
            }
            System.out.println(Thread.currentThread().getName() + "执行结束");
        }
    }

}

执行结果：

【JUC基础】09. LockSupport_jvm_09