关于java线程的interrupt方法的使用总结

首先要说明的就是Lock，通过查看Lock的源码可知，Lock是一个接口：

　　下面来逐个讲述Lock接口中每个方法的使用，lock()、tryLock()、tryLock(long time, TimeUnit unit)和lockInterruptibly()是用来获取锁的。unLock()方法是用来释放锁的。newCondition()这个方法暂且不在此讲述，会在后面的线程协作一文中讲述。

　　在Lock中声明了四个方法来获取锁，那么这四个方法有何区别呢？

　　首先lock()方法是平常使用得最多的一个方法，就是用来获取锁。如果锁已被其他线程获取，则进行等待。

　　由于在前面讲到如果采用Lock，必须主动去释放锁，并且在发生异常时，不会自动释放锁。因此一般来说，使用Lock必须在try{}catch{}块中进行，并且将释放锁的操作放在finally块中进行，以保证锁一定被被释放，防止死锁的发生。通常使用Lock来进行同步的话，是以下面这种形式去使用的：

　　tryLock()方法是有返回值的，它表示用来尝试获取锁，如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），则返回false，也就说这个方法无论如何都会立即返回。在拿不到锁时不会一直在那等待。

　　tryLock(long time, TimeUnit unit)方法和tryLock()方法是类似的，只不过区别在于这个方法在拿不到锁时会等待一定的时间，在时间期限之内如果还拿不到锁，就返回false。如果如果一开始拿到锁或者在等待期间内拿到了锁，则返回true。

　　所以，一般情况下通过tryLock来获取锁时是这样使用的：

　　lockInterruptibly()方法比较特殊，当通过这个方法去获取锁时，如果线程正在等待获取锁，则这个线程能够响应中断，即中断线程的等待状态。也就使说，当两个线程同时通过lock.lockInterruptibly()想获取某个锁时，假若此时线程A获取到了锁，而线程B只有在等待，那么对线程B调用threadB.interrupt()方法能够中断线程B的等待过程。

　　由于lockInterruptibly()的声明中抛出了异常，所以lock.lockInterruptibly()必须放在try块中或者在调用lockInterruptibly()的方法外声明抛出InterruptedException。

　　因此lockInterruptibly()一般的使用形式如下：

　　注意，当一个线程获取了锁之后，是不会被interrupt()方法中断的。因为本身在前面的文章中讲过单独调用interrupt()方法不能中断正在运行过程中的线程，只能中断阻塞过程中的线程。

　　因此当通过lockInterruptibly()方法获取某个锁时，如果不能获取到，只有进行等待的情况下，是可以响应中断的。

　　而用synchronized修饰的话，当一个线程处于等待某个锁的状态，是无法被中断的，只有一直等待下去。

以上摘自 海子的博客：http://www.cnblogs.com/dolphin0520/p/3923167.html

下面说说我的理解：

就是线程的interrupt方法会怎么终止一个线程：

分几种情况：

1、线程运行时，线程运行时，interrupt方法只会设置线程的中断标志，但是不会抛出异常，等到线程阻塞时再处理

2、线程阻塞时，会直接抛出异常

3、当线程处于锁等待时，如Lock的lock方法synchronized锁，这时的情况同1一样，不会立即处理异常，而是继续等待获取锁。

但是如果是Lock的lockInterruptibly方法时，在等待锁时，则会优先处理异常。

package qunaer;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Scanner;

import java.util.Set;

import java.util.concurrent.atomic.AtomicInteger;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

public class Main1 {

static Lock lock=new ReentrantLock();

public static void main(String[] args) {

Thread t1= new Thread(){

public void run() {

try {

lock.lock();

System.out.println("1获取锁");

sleep(1000);

lock.unlock();

System.out.println("1释放锁");

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

System.out.println("interrupted");

}

};

};

t1.start();

Thread t2= new Thread(){

public void run() {

try {

System.out.println(Thread.currentThread().isInterrupted());

sleep(10);

System.out.println(Thread.currentThread().isInterrupted());

lock.lock();

System.out.println("2获取锁");

System.out.println(Thread.currentThread().isInterrupted());

sleep(10);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

// e.printStackTrace();

System.out.println("interrupted");

}

};

};

t2.start();

try {

Thread.sleep(100);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

t2.interrupt();

}

}

运行结果：

false

1获取锁

false

1释放锁

2获取锁

true

interrupted