下面介绍取消线程常用的4中方式：
一、通过设置“cancelled requested”标志来中断线程
java中的任务取消实现：
是通过一个协作机制完成的，使用一个线程能够要求另一个线程停止当前的工作。
这样做的原因是：
如果直接要求一个任务、线程或者服务立即停止，可能会导致共享的数据结构处于不一致的状态。
当要求他们停止时，他们首先会清除当前进程中的工作，然后再终止。提供了更好的灵活性。因为
任务代码本身比发出取消请求的代码更明确应该清除什么。
典型的协作机制：
设置“cancelled requested”标志，任务会定期查看；
如果发现标志被设置过，任务就会提前结束。
一般为了让这个标志变量的状态更可靠一点，cancelled最好是volatile类型的。
取消策略：
说明关于取消的“how”,"when","what"————代码如何请求取消任务，任务在什么
时候检查取消的请求是否到达，响应取消请求的任务中应有的行为。
public class CancelThread {
/**
* 生成素数任务
* @author hadoop
*
*/
class PrimeGenerator implements Runnable{
private final List<BigInteger> primes = new ArrayList<BigInteger>();
private volatile boolean cancelled;
@Override
public void run() {
BigInteger p = BigInteger.ONE;
while(!cancelled){
//得到下一个素数
p = p.nextProbablePrime();
synchronized (this) {
primes.add(p);
}
}
}
public void cancel(){
cancelled = true;
}
public synchronized List<BigInteger> get(){
return new ArrayList<BigInteger>(primes);
}
}
/**
* 生成素数的程序运行1s钟后，取消任务
* @return
* @throws InterruptedException
*/
List<BigInteger> aSecondOfPrimes() throws InterruptedException{
PrimeGenerator generator = new PrimeGenerator();
new Thread(generator).start();
try {
TimeUnit.SECONDS.sleep(1);
}finally{
generator.cancel();
}
return generator.get();
}
public static void main(String[] args) throws InterruptedException {
CancelThread cancelThread = new CancelThread();
List<BigInteger> bList = cancelThread.aSecondOfPrimes();
for (BigInteger bigInteger : bList) {
System.out.println(bigInteger);
}
}
}二、通过线程的interrupt()方法来中断线程
中断通常是实现取消最明智的选择
中断线程
中断：本身并不会真正中断一个正在运行的线程，仅仅发出中断请求，线程自己会在下一个方便的时刻中断
（这些时刻被称为取消点，cancellation point）
有些方法如wait，sleep和join方法，当接收一个中断请求时，会抛出一个异常，或者进入时中断状态就已经被设置了。
可阻塞的库函数，通过抛出InterruptedException作为中断的响应
常用的取消机制（设置“cancelled requested”标志）不能与可阻塞的库函数进行良好的互动。阻塞会导致中断无法立刻响应，或干脆无法响应。
如果任务代码响应中断，那么可以使用中断作为你的取消机制，而不是boolean标志来请求取消。
示例中进行了两个点的中断检查：
1.调用阻塞的put方法时
2.循环开始出显示地采集中断状态。
中断策略：
决定线程如何应对中断请求————当发现中断请求时，它会做什么，哪些工作单元对应中断来说是原子操作，
以及在多快的时间里响应中断。
线程应该只能被线程的所有者中断；所有者可以把线程的中断策略信息封装到一个合适的取消机制中，比如关闭（shutdown）方法
public class InterruptThread {
/**
* 素数生产者，向阻塞队列中放入内容
* @author hadoop
*
*/
class BrokenPrimePreducer extends Thread{
private final BlockingQueue<BigInteger> queue;
private volatile boolean cancelled = false;
BrokenPrimePreducer(BlockingQueue<BigInteger> queue){
this.queue = queue;
}
public void run(){
try {
BigInteger p = BigInteger.ONE;
while(!Thread.currentThread().isInterrupted()){//第一出检查中断
//第二次检查中断，put操作中 notFull.await();在等待操作中会检查线程是否中断
queue.put(p = p.nextProbablePrime());
}
} catch (InterruptedException e) {
System.out.println("进行中断的逻辑处理");
}
}
public void cancel(){
this.interrupt();
}
}
void consumePrimes() throws InterruptedException{
//阻塞队列中只能存放5个对象
BlockingQueue<BigInteger> primes = new ArrayBlockingQueue<BigInteger>(5);
BrokenPrimePreducer producer = new BrokenPrimePreducer(primes);
long start = System.currentTimeMillis();
//开始执行线程，向队列中存放内容
producer.start();
long useTime = 0;
try {
while(needMorePrimes(useTime)){//是否需要更多的素数对象
Thread.sleep(40);
//这里取消消费者，让堵塞队列始终处于调用put的堵塞状态，这样就始终不会再对cancelled取消标志进行判断了，所以通过取消标志无法取消任务
//primes.take();
useTime = System.currentTimeMillis() - start;
}
}finally{
producer.cancel();
for (BigInteger bigInteger : primes) {
System.out.println(bigInteger);
}
}
}
/**
* 判断是否需要更多的素数
* 方法开始5s后，不再需要素数
* @return
*/
boolean needMorePrimes(long useTime){
return useTime < 5000 ?true :false;
}
public static void main(String[] args) throws InterruptedException {
InterruptThread it = new InterruptThread();
it.consumePrimes();
}
}三、通过future取消任务
单个任务的取消还能通过future来实现
future.cancel(boolean mayInterruptIfRunning)
参数mayInterruptIfRunning：
@param mayInterruptIfRunning <tt>true</tt> if the thread executing this
* task should be interrupted; otherwise, in-progress tasks are allowed
* to complete
如果为ture，就让执行中的任务立刻中断；如果为false，执行中任务会被执行完毕。
package com.thread;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
/**
* 通过Future实现取消线程
* @author hadoop
*
*/
public class FutureCanceled {
//固定大小的线程池，同时只能接受5个任务
static ExecutorService mExecutor = Executors.newFixedThreadPool(5);
public static void timedRun(Runnable r,long timeout,TimeUnit unit) throws Throwable {
Future<?> task = mExecutor.submit(r);
try {
task.get(timeout, unit);
} catch (TimeoutException e) {
System.out.println("处理超时异常");
} catch (ExecutionException e) {
System.out.println("处理执行异常");
throw new Throwable(e.getCause());
} finally{
task.cancel(true);
}
}
}
四、通过停止基于线程的服务取消任务
应用程序通常会创建拥有线程的服务，比如线程池。线程的拥有者就是创建线程的类。
所以线程池拥有它的工作者线程。如果需要中断这些线程，那么应该由线程池来负责。
应用程序拥有服务，服务拥有工作者线程，而应用程序并不拥有工作者线程。因此应用程序不应该视图直接停止工作者线程。而是通过服务来管理线程。
ExecutorService提供了shutdown和shutdownNow方法来关闭线程。
package com.thread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* ShutDown关闭线程池测试
* @author hadoop
*
*/
public class ShutDownThreadPool {
//固定大小的线程池，同时只能接受5个任务
static ExecutorService mExecutor = Executors.newFixedThreadPool(5);
/*
* 采用线程池开启多个子线程，主线程等待所有的子线程执行完毕
*/
public static void moreThread() {
try {
int threadNum = 0;
/**
* 尽管线程池只能同时开启5个线程处理任务，但是10个任务已经放入处理队列中，尽管调用了shutdown方法，已放入的10个任务仍然会执行完成。
* 但是调用了shutdown方法后，就不能再向线程池中添加新任务来了，否则会抛RejectedExecutionException异常
*/
for (int i = 0; i < 10; i++) {
threadNum++;
final int currentThreadNum = threadNum;
mExecutor.execute(new Runnable() {
@Override
public void run() {
try {
System.out.println("子线程[" + currentThreadNum + "]开启");
Thread.sleep(1000*10);
} catch (InterruptedException e) {
e.printStackTrace();
}finally{
System.out.println("子线程[" + currentThreadNum + "]结束");
}
}
});
}
System.out.println("已经开启所有的子线程");
mExecutor.shutdown();
System.out.println("shutdown()：启动一次顺序关闭，执行以前提交的任务，但不接受新任务。");
int threadNum2 = 0;
for (int i = 20; i < 30; i++) {
threadNum2++;
final int currentThreadNum = threadNum2;
mExecutor.execute(new Runnable() {
@Override
public void run() {
try {
System.out.println("尝试再次添加任务：子线程[" + currentThreadNum + "]开启");
Thread.sleep(1000*10);
} catch (InterruptedException e) {
e.printStackTrace();
}finally{
System.out.println("子线程[" + currentThreadNum + "]结束");
}
}
});
}
/**
* 只有执行了shutdown方法，执行isTerminated才有效。否则isTerminated一直为ture
*/
while(true){
if(mExecutor.isTerminated()){
System.out.println("所有的子线程都结束了！");
break;
}
Thread.sleep(1000);
}
} catch (InterruptedException e) {
e.printStackTrace();
}finally{
System.out.println("主线程结束");
}
}
public static void main(String[] args) {
moreThread();
}
}