lock.lock()和lock.lockInterruptibly()的区别

一开始容易搞混两者的区别，看官方的说明看的也有点晕晕的。通过实验了几次，终于明白了，其实两者的区别就一句话：

lock.lock()和lock.lockInterruptibly()在等待获取锁的时候，线程的interrupt()无法打断lock.lock()，但是可以打断lock.lockInterruptibly()。

这句话有个非常重要的场景，就是这俩方法都是在等待获取锁的时候，才会有被打断一说。如果他们执行的时候已经直接获取到锁，是直接返回了。即便线程再次打断，也没法打断。除非线程执行打断的时候，线程中在执行其他的线程阻塞方法如sleep()/join()。

另外有一点，如果lock.lockInterruptibly() 在等待锁的过程中被打断了，其后续的业务代码是不会被执行的，需要catch这个InterruptedException异常进行额外的处理。并且打断后，lock.unlock()执行会报IllegalMonitorStateException异常，这是因为线程打算锁之后，当前线程不再持有锁，也就不存在当前线程去释放锁。

public class TestReenLockInterrupt {

    public static void main(String[] args) throws InterruptedException  {
        testInterrupt();
    }

    /**
     * 可打断
     *
     */
    public static void testInterrupt() throws InterruptedException {
        ReentrantLock lock = new ReentrantLock();
        Thread t2 = new Thread(() -> m2(lock));
        Thread t1 = new Thread(() -> m1(lock));
        t2.start();
        Thread.sleep(2000);
        t1.start();
        try {
            System.out.println("3秒后打断t2");
            Thread.sleep(3000);
            t2.interrupt();
            System.out.println("3秒后打断t1");
            Thread.sleep(3000);
            t1.interrupt();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

    public static void m1(ReentrantLock lock) {
        try {
            lock.lockInterruptibly();
            System.out.println("我是方法1，睡");
        } catch (InterruptedException e) {
            System.out.println("我被打断了。。。。。。");
        } finally {
            if(lock.isHeldByCurrentThread()){
                lock.unlock();
            } else{
                System.out.println("当前线程不持有锁");
            }
        }
    }

    private static void m2(ReentrantLock lock) {
        try {
            lock.lock();
            System.out.println("m2获取到了锁");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}