LockSupport的park和unpark的基本使用,以及对线程中断的响应性

文章来源：http://blog.csdn.net/aitangyong/article/details/38373137

 LockSupport是JDK中比较底层的类，用来创建锁和其他同步工具类的基本线程阻塞原语。java锁和同步器框架的核心AQS:AbstractQueuedSynchronizer，就是通过调用LockSupport.park()和LockSupport.unpark()实现线程的阻塞和唤醒的。LockSupport很类似于二元信号量(只有1个许可证可供使用)，如果这个许可还没有被占用，当前线程获取许可并继续执行；如果许可已经被占用，当前线程阻塞，等待获取许可。

[java]  view plain  copy

1. public static void main(String[] args)  
2. {  
3.      LockSupport.park();  
4.      System.out.println("block.");  
5. }  

运行该代码，可以发现主线程一直处于阻塞状态。因为许可默认是被占用的，调用park()时获取不到许可，所以进入阻塞状态。

如下代码：先释放许可，再获取许可，主线程能够正常终止。LockSupport许可的获取和释放，一般来说是对应的，如果多次unpark，只有一次park也不会出现什么问题，结果是许可处于可用状态。

[java]  view plain  copy

1. public static void main(String[] args)  
2. {  
3.      Thread thread = Thread.currentThread();  
4.      LockSupport.unpark(thread);//释放许可  
5.      LockSupport.park();// 获取许可  
6.      System.out.println("b");  
7. }  

 

LockSupport是不可重入的，如果一个线程连续2次调用LockSupport.park()，那么该线程一定会一直阻塞下去。

[java]  view plain  copy

1. public static void main(String[] args) throws Exception  
2. {  
3.     Thread thread = Thread.currentThread();  
4.       
5.     LockSupport.unpark(thread);  
6.       
7.     System.out.println("a");  
8.     LockSupport.park();  
9.     System.out.println("b");  
10.     LockSupport.park();  
11.     System.out.println("c");  
12. }  

这段代码打印出a和b，不会打印c，因为第二次调用park的时候，线程无法获取许可出现死锁。

下面我们来看下LockSupport对应中断的响应性

[java]  view plain  copy

1. public static void t2() throws Exception  
2. {  
3.     Thread t = new Thread(new Runnable()  
4.     {  
5.         private int count = 0;  
6.   
7.         @Override  
8.         public void run()  
9.         {  
10.             long start = System.currentTimeMillis();  
11.             long end = 0;  
12.   
13.             while ((end - start) <= 1000)  
14.             {  
15.                 count++;  
16.                 end = System.currentTimeMillis();  
17.             }  
18.   
19.             System.out.println("after 1 second.count=" + count);  
20.   
21.         //等待或许许可  
22.             LockSupport.park();  
23.             System.out.println("thread over." + Thread.currentThread().isInterrupted());  
24.   
25.         }  
26.     });  
27.   
28.     t.start();  
29.   
30.     Thread.sleep(2000);  
31.   
32.     // 中断线程  
33.     t.interrupt();  
34.   
35.       
36.     System.out.println("main over");  
37. }  

最终线程会打印出thread over.true。这说明线程如果因为调用park而阻塞的话，能够响应中断请求(中断状态被设置成true)，但是不会抛出InterruptedException。

使用LockSupport来进行线程交互：

@Test
    public void testLock() throws InterruptedException {
        Object lock = new Object();

        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                LockSupport.park(lock);
                System.out.println("thread...");

            }
        });
        thread.start();

        Thread.sleep(1000);
        System.out.println("main.....");
        LockSupport.unpark(thread);


        Thread.sleep(1000);

    }