Java并发编程-07 LockSupport详解

LockSupport是锁中的基础，是提供锁机制的工具类

---

为什么LockSupport也是核心基础类?

AQS框架借助于两个类：Unsafe(提供CAS操作)和LockSupport(提供park/unpark操作)

LockSupport用来创建锁和其他同步类的基本线程阻塞原语。简而言之，当调用LockSupport.park时，表示当前线程将会等待，直至获得许可，当调用LockSupport.unpark时，必须把等待获得许可的线程作为参数进行传递，好让此线程继续运行。

写出分别通过wait/notify和LockSupport的park/unpark实现同步?

wait/notify：

class MyThread extends Thread {
    public void run() {
        synchronized (this) {
            System.out.println("before notify");            
            notify();
            System.out.println("after notify");    
        }
    }
}

public class WaitAndNotifyDemo {
    public static void main(String[] args) throws InterruptedException {
        MyThread myThread = new MyThread();        
        myThread.start();
        // 主线程睡眠3s
        Thread.sleep(3000);
        synchronized (myThread) {
            try {        
                System.out.println("before wait");
                // 阻塞主线程
                myThread.wait();
                System.out.println("after wait");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }            
        }        
    }
}

park/unpark

import java.util.concurrent.locks.LockSupport;

class MyThread extends Thread {
    private Object object;

    public MyThread(Object object) {
        this.object = object;
    }

    public void run() {
        System.out.println("before unpark");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 获取blocker
        System.out.println("Blocker info " + LockSupport.getBlocker((Thread) object));
        // 释放许可
        LockSupport.unpark((Thread) object);
        // 休眠500ms，保证先执行park中的setBlocker(t, null);
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 再次获取blocker
        System.out.println("Blocker info " + LockSupport.getBlocker((Thread) object));

        System.out.println("after unpark");
    }
}

public class test {
    public static void main(String[] args) {
        MyThread myThread = new MyThread(Thread.currentThread());
        myThread.start();
        System.out.println("before park");
        // 获取许可
        LockSupport.park("ParkAndUnparkDemo");
        System.out.println("after park");
    }
}

LockSupport.park()会释放锁资源吗? 那么Condition.await()呢?

LockSupport.park()和Thread.sleep()方法类似都是使线程阻塞并且不会释放资源，区别是sleep方法只能自己唤醒自己，而park方法可以被其他线程调用LockSupport.unpark()方法唤醒，sleep方法是一个native方法，LockSupport.park方法则是调用了unsafe.park方法

Condition.await虽然底层调用了LockSupport.park方法（也就是阻塞线程之前）但是在调用该方法前还进行一是把当前线程添加到条件队列中，二是“完全”释放锁

Thread.sleep()、Object.wait()、Condition.await()、LockSupport.park()的区别?

Thread.sleep()、Object.wait():

1. wait可以释放资源，sleep不会释放资源
2. wait可不填时间（只能等notify释放，不一定会立即得到锁），sleep一定要填时间

Thread.sleep()、Condition.await():
3. Object.wait()和Condition.await()的原理是基本一致的，不同的是Condition.await()底层是调用LockSupport.park()来实现阻塞当前线程的。
4. 实际上，它在阻塞当前线程之前还干了两件事，一是把当前线程添加到条件队列中，二是“完全”释放锁，也就是让state状态变量变为0，然后才是调用LockSupport.park()阻塞当前线程。

·Thread.sleep()和LockSupport.park():

1. 都阻塞线程，都不会释放资源
2. sleep（native）只能自己唤醒自己，LockSupport.park（不是native）需要等其他线程调用unpark方法，该方法调用后以后会立即获得锁

Object.wait()和LockSupport.park()

1. wait如果在wait()之前执行了notify()会怎样? 抛出IllegalMonitorStateException异常；
2. 如果在park()之前执行了unpark()会怎样? 线程不会被阻塞，直接跳过park()，继续执行后续内容；