java并发库中的LockSupport介绍及使用

在没有接触到LockSupport类之前，我一直很疑惑jdk并发库中的很多工具类到底是怎么实现让线程阻塞的呢？最典型的就是futureTask，主线程调用get()方法会一直阻塞直到结果返回。据我所知，能让线程阻塞（注意不是休眠）的实现方式是在同步块中调用锁对象的wait()方法，如下所示：

		synchronized (object) {
			try {
				//进入阻塞状态，直到有其他线程将其唤醒
				object.wait();
			} catch (InterruptedException e) {
				//恢复中断标记
			    Thread.currentThread().interrupt();
			}
			
			//do something
		}

但看过大神的jdk并发库部分源码之后，才知道 LockSupport的存在。查看其源码可发现它并没有使用标准的jdk API来实现，而是通过大名鼎鼎的Unsafe工具类来调用操作系统底层API实现的。通过查看其API文档，发现它也引入了“许可”的概念，大致上就是说只有获得“许可”，线程才能继续运行，否则将阻塞。常用的API如下所示：

static void park()	若当前线程有许可，立即返回。否则阻塞，直到某些条件发生
static void parkNanos(long nanos)	同上，并可以设置超时时间
static void park(Object blocker)	同上，并可以设置一个标记对象，其实这个对象仅仅是方便查看日志 时，可以看到这个线程因获取哪个锁对象而阻塞 （看过thread dump日志的都知道咋回事）
static void unpark(Thread thread)	给定线程发放许可，一个线程最多只能有一个许可 （连续调用多次是没有用的）

API中还需要注意LockSupport.park()的特性说明：

若当前线程有许可，立即返回。否则阻塞，直到以下条件触发

（1）其他线程调用了LockSupport.unpark()来对该线程发放许可

（2）其他线程调用了该线程的interrupt()方法进行中断，注意是不会抛出InterruptedException

（3）没有理由（意思是该方法底层实现无法完全保证线程一直处于阻塞，因此建议在循环块调用该方法）

学习了以上的一些特性后，我也尝试写了了一个demo来加深了解，代码如下：

public class BlockThread {
    private volatile boolean blocked = false; 
    private Thread current;
    
    public BlockThread() {
        super();
        this.current = Thread.currentThread();
    }
    
    public Thread getTargetThread() {
        return this.current;
    }

    public void block() {
        doBlock(false ,0L);
    }
    
    public void block(long timeout, TimeUnit unit) {
        doBlock(true, unit.toNanos(timeout));
    }
    
    private void doBlock(boolean timed, long nanos) {
        if(current != Thread.currentThread()) {
            throw new RuntimeException();
        }
        
        final long deadline = timed ? System.nanoTime() + nanos : 0L;
        blocked = true;
        while(blocked) {
            if(timed) {//如果设置了超时时间，则需要判断是否超时
                nanos = deadline - System.nanoTime();
                if (nanos > 0L) {
                	//还没超时，继续阻塞
                    LockSupport.parkNanos(this, nanos);
                }else{
                    blocked = false;
                }
            }else{
                LockSupport.park(this);
            }
            
            if(current.isInterrupted()) {
                blocked = false;
            }
        }
    }


    public void unblock() {
        if(blocked) {
            blocked = false;
            LockSupport.unpark(current);
        }
    }
    
    public static void main(String[] args) {
        final BlockThread bt = new BlockThread();
        
        new Thread() {
            @Override
            public void run() {
                try {
                    Thread.sleep(10000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                bt.unblock();
                System.out.println("unblock");
                
                //中断也可以
                //bt.getTargetThread().interrupt();
                //System.out.println("interrupted");
            }
        }.start();
        
        System.out.println("block");
        bt.block();
        
        System.out.println("complete");
    }
}