无风无影

   ::  :: 新随笔  ::  ::  :: 管理

Lock体系-Lock接口及LockSupport类

Lock接口

　　Lock不是Java中的关键字而是 java.util.concurrent.locks 包中的一个接口

 

　　

 

 

public interface Lock {
　　//获取锁。如果锁不可用，出于线程调度目的，将禁用当前线程，并且在获得锁之前，该线程将一直处于休眠状态
    void lock();

　　//可中断地获取锁，和lock()方法的不同之处在于该方法会响应中断，即在锁的获取中可以中断当前线程
　　void lockInterruptibly() throws InterruptedException;

　　//释放锁。在等待条件前，锁必须由当前线程保持。调用 Condition.await() 将在等待前以原子方式释放锁，并在等待返回前重新获取锁
    void unlock();

　　//获取等待通知组件，该组件和当前的锁绑定，当前线程只有获取了锁，才能调用该组件的wait()方法，而调用后，当前线程将释放锁
    Condition newCondition();

　　//尝试非阻塞的获取锁，调用该方法后立刻返回，若能获取则返回true，反之亦然。

　　　 boolean tryLock()
　　　

　　// 超时的获取锁，当前线程在以下3种情况下会返回1.当前线程在超时时间内获得了锁 2.当前线程在超时时间内被中断3.超时时间结束，返回false 

　　  boolean tryLock(long time, TimeUnit unit)




}




 


 


LockSupport简介




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


　　我们可以使用它来阻塞和唤醒线程,功能和wait,notify有些相似,但是LockSupport比起wait,notify功能更强大，也好用的多。


　　使用wait，notify来实现等待唤醒功能至少有两个缺点：


    

  • 1.由上面的例子可知,wait和notify都是Object中的方法,在调用这两个方法前必须先获得锁对象，这限制了其使用场合:只能在同步代码块中。
    • 



    

  • 2.另一个缺点可能上面的例子不太明显，当对象的等待队列中有多个线程时，notify只能随机选择一个线程唤醒，无法唤醒指定的线程。
    • 



　　而使用LockSupport的话，我们可以在任何场合使线程阻塞，同时也可以指定要唤醒的线程，相当的方便。


　　类的构造函数


　　LockSupport只有一个私有构造函数，无法被实例化




// 私有构造函数，无法被实例化
 private LockSupport() {}




　　核心函数分析


　　LockSupport的核心函数都是基于sun.misc.Unsafe类中的park和unpark函数，下面给出两个函数的定义:




    

  • 

    park函数，阻塞线程，并且该线程在下列情况发生之前都会被阻塞: ① 调用unpark函数，释放该线程的许可。② 该线程被中断。③ 设置的时间到了。并且，当time为绝对时间时，isAbsolute为true，否则，isAbsolute为false。当time为0时，表示无限等待，直到unpark发生。
    

    • 

  • 

    unpark函数，释放线程的许可，即激活调用park后阻塞的线程。这个函数不是安全的，调用这个函数时要确保线程依旧存活。     
    

    • 







public native void park(boolean isAbsolute, long time); 
public native void unpark(Thread thread);




　　


　　park函数：


　　park函数有两个重载版本，方法摘要如下：　




public static void park()；
public static void park(Object blocker)；




　　说明: 两个函数的区别在于park()函数没有没有blocker，即没有设置线程的parkBlocker字段。park(Object)型函数如下。


　　调用了park函数后，会禁用当前线程，除非许可可用。在以下三种情况之一发生之前，当前线程都将处于休眠状态，即下列情况发生时，当前线程会获取许可，可以继续运行。


    

  • 其他某个线程将当前线程作为目标调用 unpark。
    • 

  • 其他某个线程中断当前线程。
    • 

  • 该调用不合逻辑地(即毫无理由地)返回。
    • 



　　　


　　如下park方法代码，首先获取当前线程，然后设置当前线程的parkBlocker字段，即调用setBlocker函数，之后调用Unsafe类的park函数，之后再调用setBlocker函数。


　　那么问题来了，为什么要在此park函数中要调用两次setBlocker函数呢？原因其实很简单，调用park函数时，当前线程首先设置好parkBlocker字段，然后再调用Unsafe的park函数，此后，当前线程就已经阻塞了，等待该线程的unpark函数被调用，所以后面的一个setBlocker函数无法运行，unpark函数被调用，该线程获得许可后，就可以继续运行了，也就运行第二个setBlocker，把该线程的parkBlocker字段设置为null，这样就完成了整个park函数的逻辑。如果没有第二个setBlocker，那么之后没有调用park(Object blocker)，而直接调用getBlocker函数，得到的还是前一个park(Object blocker)设置的blocker，显然是不符合逻辑的。总之，必须要保证在park(Object blocker)整个函数执行完后，该线程的parkBlocker字段又恢复为null。所以，park(Object)型函数里必须要调用setBlocker函数两次。




public static void park(Object blocker) {
    // 获取当前线程
    Thread t = Thread.currentThread();
    // 设置Blocker
    setBlocker(t, blocker);
    // 获取许可
    UNSAFE.park(false, 0L);
    // 重新可运行后再此设置Blocker
    setBlocker(t, null);
}





private static void setBlocker(Thread t, Object arg) {
    // 设置线程t的parkBlocker字段的值为arg
    UNSAFE.putObject(t, parkBlockerOffset, arg);
}






　　parkNanos函数 此函数表示在许可可用前禁用当前线程，并最多等待指定的等待时间。




 public static void parkNanos(Object blocker, long nanos)




　　parkUntil函数 此函数表示在指定的时限前禁用当前线程，除非许可可用, deadline参数表示绝对时间，表示指定的时间




public static void parkUntil(Object blocker, long deadline)




　　unpark函数 此函数表示如果给定线程的许可尚不可用，则使其可用。如果线程在 park 上受阻塞，则它将解除其阻塞状态。否则，保证下一次调用 park 不会受阻塞。如果给定线程尚未启动，则无法保证此操作有任何效果




public static void unpark(Thread thread) 




　　使用park/unpark实现线程同步


　　注意：下面的例子，如果在park()之前执行了unpark()会怎样？线程不会被阻塞，直接跳过park()，继续执行后续内容；




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");
    }
}






 


    

  • 为什么可以先唤醒线程后阻塞线程？
    • 


  • 因为unpark获得了一个凭证,之后调用park因为有凭证消费，故不会阻塞。
    • 



 


    

  • 为什么唤醒两次后阻塞两次会阻塞线程。
    • 




　　因为凭证的数量最多为1，连续调用两次unpark和调用一次unpark效果一样，只会增加一个凭证；而调用两次park却需要消费两个凭证。




Thread.sleep()和Object.wait()的区别


    

  • Thread.sleep()不会释放占有的锁，Object.wait()会释放占有的锁；
    • 

  • Thread.sleep()必须传入时间，Object.wait()可传可不传，不传表示一直阻塞下去；
    • 

  • Thread.sleep()到时间了会自动唤醒，然后继续执行；
    • 

  • Object.wait()不带时间的，需要另一个线程使用Object.notify()唤醒；
    • 

  • Object.wait()带时间的，假如没有被notify，到时间了会自动唤醒，这时又分好两种情况，一是立即获取到了锁，线程自然会继续执行；二是没有立即获取锁，线程进入同步队列等待获取锁；
    • 



　　其实，他们俩最大的区别就是Thread.sleep()不会释放锁资源，Object.wait()会释放锁资源。


　　Thread.sleep()和Condition.await()的区别


　　Object.wait()和Condition.await()的原理是基本一致的，不同的是Condition.await()底层是调用LockSupport.park()来实现阻塞当前线程的。


　　实际上，Condition在阻塞当前线程之前还干了两件事，一是把当前线程添加到条件队列中，二是“完全”释放锁，也就是让state状态变量变为0，然后才是调用LockSupport.park()阻塞当前线程。


　　Thread.sleep()和LockSupport.park()的区别


　　LockSupport.park()还有几个兄弟方法——parkNanos()、parkUtil()等，我们这里说的park()方法统称这一类方法。


    

  • 从功能上来说，Thread.sleep()和LockSupport.park()方法类似，都是阻塞当前线程的执行，且都不会释放当前线程占有的锁资源；
    • 

  • Thread.sleep()没法从外部唤醒，只能自己醒过来；
    • 

  • LockSupport.park()方法可以被另一个线程调用LockSupport.unpark()方法唤醒；
    • 

  • Thread.sleep()方法声明上抛出了InterruptedException中断异常，所以调用者需要捕获这个异常或者再抛出；
    • 

  • LockSupport.park()方法不需要捕获中断异常；
    • 

  • Thread.sleep()本身就是一个native方法；
    • 

  • LockSupport.park()底层是调用的Unsafe的native方法；
    • 



　　Object.wait()和LockSupport.park()的区别


　　二者都会阻塞当前线程的运行，他们有什么区别呢？经过上面的分析相信你一定很清楚了，真的吗？往下看！


    

  • Object.wait()方法需要在synchronized块中执行；
    • 

  • LockSupport.park()可以在任意地方执行；
    • 

  • Object.wait()方法声明抛出了中断异常，调用者需要捕获或者再抛出；
    • 

  • LockSupport.park()不需要捕获中断异常；
    • 

  • Object.wait()不带超时的，需要另一个线程执行notify()来唤醒，但不一定继续执行后续内容；
    • 

  • LockSupport.park()不带超时的，需要另一个线程执行unpark()来唤醒，一定会继续执行后续内容；
    • 

  • 如果在wait()之前执行了notify()会怎样？抛出IllegalMonitorStateException异常；
    • 

  • 如果在park()之前执行了unpark()会怎样？线程不会被阻塞，直接跳过park()，继续执行后续内容；
    • 



　　park()/unpark()底层的原理是“二元信号量”，你可以把它相像成只有一个许可证的Semaphore，只不过这个信号量在重复执行unpark()的时候也不会再增加许可证，最多只有一个许可证。


　　LockSupport.park()会释放锁资源吗？


　　不会，它只负责阻塞当前线程，释放锁资源实际上是在Condition的await()方法中实现的。











        

	
        

            posted on 
2019-12-24 11:01 
NWNS-无风无影 
阅读(195) 
评论(0) 
 
收藏 
举报