Java没有安全的抢占方法来停止线程，只有协作式的机制，使代码遵循一种协商好的协议来提前结束线程。
其中一种协作机制是通过设置标志（已请求取消），任务将定期查看该标志，如果设置了该标志，则任务提前结束。
例如我们可以通过volatile类型域（关于volatitle类型域的特点和作用本篇不做介绍，不了解的同学可以自行搜索）来取消，设置变量private volatile boolean cancelled = false;
在任务中循环判断cancelled来跳出循环
private volatile boolean cancelled = false;
while(!cancelled){
System.out.println(" queue.put 1");
queue.put(p = p.nextProbablePrime());
System.out.println(" queue.put 2");
}
public void cancel(){
// interrupt();
cancelled = true;
System.out.println(" cancel ");
}
但如果使用这个方法的任务中调用了阻塞方法，可能会因为阻塞而存在代码永远不会执行到检查标志位的地方，因此永远不会结束（一直卡在阻塞位置）
LOG如下：
queue.put 1
queue.put 2
queue.put 1
queue.put 2
queue.put 1
queue.put 2
queue.put 1
queue.put 2
queue.put 1
consume value = 2
cancel
所以保险情况是通过中断来取消
完整代码如下
package com.thread.test.interrupt;
import java.math.BigInteger;
import java.util.List;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import static java.util.concurrent.TimeUnit.SECONDS;
public class PrimeProducer extends Thread {
private final BlockingQueue<BigInteger> queue;
private volatile boolean cancelled = false;
public PrimeProducer(BlockingQueue<BigInteger> queue) {
// TODO Auto-generated constructor stub
this.queue = queue;
}
public void run() {
try{
BigInteger p = BigInteger.ONE;
// // volatile类型域
// while(!cancelled){
// System.out.println(" queue.put 1");
// queue.put(p = p.nextProbablePrime());
// System.out.println(" queue.put 2");
// }
// while(!Thread.currentThread().isInterrupted()){
// System.out.println(" queue.put 1");
// queue.put(p = p.nextProbablePrime());
// System.out.println(" queue.put 2");
// }
while(true){
if(Thread.currentThread().isInterrupted()){
System.out.println(" isInterrupted ");
break;
}
System.out.println(" queue.put 1");
queue.put(p = p.nextProbablePrime());
System.out.println(" queue.put 2");
}
}catch(InterruptedException e){
System.out.println(" InterruptedException e");
}
}
public void cancel(){
interrupt();
// cancelled = true;
System.out.println(" cancel ");
}
public static boolean needMroePrime(int count){
if(count >= 1){
return false;
}else{
return true;
}
}
public static void consume(BigInteger value){
System.out.println(" consume value = "+value);
}
public static void main(String[] args) {
final BlockingQueue<BigInteger> prime = new ArrayBlockingQueue<BigInteger>(3);
PrimeProducer producer = new PrimeProducer(prime);
producer.start();
int count = 0;
try{
SECONDS.sleep(1);
while(needMroePrime(count)){
count++;
consume(prime.take());
}
}catch(InterruptedException e){
}finally{
producer.cancel();
}
}
}
程序运行结果示例：
queue.put 1
queue.put 2
queue.put 1
queue.put 2
queue.put 1
queue.put 2
queue.put 1
queue.put 2
queue.put 1
consume value = 2
cancel
InterruptedException e
从LOG执行情况我们可以看到，线程虽然还是阻塞在put方法中，但还是通过抛出异常而退出，进一步查看源码我们可以发现在BlockingQueue的put方法中会抛出InterruptedException异常，并注明 InterruptedException if interrupted while waiting
（继续深入源码可以发现阻塞实际是一个while循环不断执行，再循环中会判断Thread.interrupted()，中断则抛出InterruptedException， AbstractQueuedSynchronizer$ConditionObject）
另外一些阻塞库方法，例如Thread.sleep和Object.wait等，都会检查线程何时中断，并再发现中断时提前返回，清除中断状态并抛出异常。
我们得出如下结论：
通常，中断是实现取消最合理的方式
其他中断线程的方法：
Thread.stop()，此方法由于严重的缺陷以及被废弃，非常不建议使用，具体原因大家可自行查找
为什么要使用抛出InterruptedException的方式：
- 首先，我们再次回顾一下线程取消的概念，是让任务提前结束，提前结束的意思可以理解线程Run方法中没有代码需要执行
- 线程中断本质上也是通过判断标志位进而抛出InterruptedException异常，抛出异常后线程实际上还没有退出，捕获异常之后如果直接不处理或者在Run方法中直接return则线程就被取消了，如果还有一些操作（比如例子中的打印日志），代码还是会执行，这里可以做一些中断策略的设计，一般我们会用来复位一些标记位，做一些资源释放的逻辑。
- 如果不使用抛出异常的方式会怎么样？比如在循环中我们可以通过break提前退出，再方法函数中我们可以通过return提前退出，但异常更好，异常可以不断向上抛出（避免多个函数嵌套如果不用异常则需要不停return），只有在捕获的地方进行处理（代码逻辑会更清晰），甚至可以处理之后继续向上抛出，可以非常灵活的使用，这里可以参考这篇文章 https://www.cnblogs.com/greta/p/5624839.html
附录
Thread中的中断方法说明
public class Thread{
public void interrupt(){...}
public boolean isInterrupted(){...}
public static boolean interrupted(){
return currentThread().isInterrupted(true);
}
// 确定线程是否被中断，根据ClearInterrupted值决定是否重置
private native boolean isInterrupted(boolean ClearInterrupted);
}
