聊聊Lock接口的lock()和lockInterruptible()有什么区别？

lock()和lockInterruptible()都表示获取锁，唯一区别是，当A线程调用lock()或lockInterruptible()方法获取锁没有成功而进入等待锁的状态时，若接着调用该A线程的interrupt()方法中断该线程的等待：

• 如果A线程是通过lock()获取锁失败而进入等待状态的：则A线程不会马上执行自己的interrupt()方法去中断等待，而是继续等待获取锁(同时把中断命令放入等待队列)， 获取到锁之后才响应自己的interrupt()方法去中断等待(从等待丢列中拿出中断命令执行)。获取锁之后，若A线程没有处于等待状态而调用interrupt()方法，是不会发生任何事情的，若获取锁之后A刚刚好又进入了等待状态，则执行等待丢列中的中断命令就会让A抛出InterruptedException()异常去中断等待
• 如果A线程是想通过lockInterruptible()获取锁失败而进入等待状态的：则A线程会马上响应自己的interrupt()方法抛出InterruptedException 异常去中断等待，此时在finally里处理该异常，从而接着执行其他的代码

使用lockInterruptible()获取锁的例子：

public class LockTest {
    private Lock lock = new ReentrantLock();
    public void doBussiness() {
        String name = Thread.currentThread().getName();
 
        try {
            System.out.println(name + " 开始获取锁");
            lock.lockInterruptibly();//获取锁，可以调interrupt()中断等待
            System.out.println(name + " 得到锁");
            System.out.println(name + " 开工干活");
            for (int i=0; i<5; i++) {
                Thread.sleep(1000);
                System.out.println(name + " : " + i);
            }
        } catch (InterruptedException e) {
            //用lockInterruptibly()获取锁，必须处理可能调用interrupt()而抛出的InterruptedException异常
            System.out.println(name + " 被中断");
            System.out.println(name + " 做些别的事情");
        } finally {
            try {
                lock.unlock();
                System.out.println(name + " 释放锁");
            } catch (Exception e) {
                System.out.println(name + " : 没有得到锁的线程运行结束");
            }
        }
    }
 
    public static void main(String[] args) throws InterruptedException {
 
        LockTest lockTest = new LockTest();
 
        Thread t0 = new Thread(
                new Runnable() {
                    public void run() {
                        lockTest.doBussiness();
                    }
                }
                );
 
        Thread t1 = new Thread(
                new Runnable() {
                    public void run() {
                        lockTest.doBussiness();
                    }
                }
                );
 
        // 启动线程t1
        t0.start();
        Thread.sleep(10);
        // 启动线程t2
        t1.start();
        Thread.sleep(100);
        // 线程t1没有得到锁，中断t1的等待
        t1.interrupt();
    }
}
#运行结果：
Thread-0 开始获取锁
Thread-0 得到锁
Thread-0 开工干活
Thread-1 开始获取锁
Thread-1 被中断  //线程t1用lockInterruptible()获取锁失败而进入等待时，主线程调用t1.interrupt()使该t1抛出异常从而中断等待
Thread-1 做些别的事情//t1中断等待后接着执行其他的代码
Thread-1 : 没有得到锁的线程运行结束
Thread-0 : 0
Thread-0 : 1
Thread-0 : 2
Thread-0 : 3
Thread-0 : 4
Thread-0 释放锁

　　

使用lock()获取锁的例子：

把上面第9行中lock.lockInterruptibly()改为lock.lock()，其他代码不变，则输出结果：

Thread-0 开始获取锁
Thread-0 得到锁
Thread-0 开工干活
Thread-1 开始获取锁  //t0已经获取到了锁，所以t1只能进入等待状态(线程没有获取到锁会进入等待状态)。因为t1是调用lock.lock()获取锁的，所以即便主线程调用t1.interrupt()方法，t1也不会马上响应中断(即抛出InterruptedException异常来中断自己的等待状态)，而是直到拿到锁之后才会响应中断
Thread-0 : 0
Thread-0 : 1
Thread-0 : 2
Thread-0 : 3
Thread-0 : 4  
Thread-1 得到锁  //t0打印完后已经执行了lock.unlock()释放了锁，要不然t1是拿不到锁的。同时t0还没来得及执行上面第23行代码用System打印出“Thread-0 释放锁”，时间片就轮给了t1，所以这行代码是t1执行输出的
Thread-1 开工干活
Thread-1 被中断 //由于t1拿到锁后才会去响应中断，所以上面第13行Thread.sleep(1000)在t1拿到锁之后又让t1进入了等待状态，此时t1刚刚好执行响应中断，故抛出InterruptedException来异常响应中断
Thread-1 做些别的事情
Thread-0 释放锁
Thread-1 释放锁  //t0早就释放了锁，在这里重新获得了时间片进行打印操作