线程中断机制，精确控制方法执行

在Java中，有没有一种方式，可以使正在执行的方法，终止执行呢？

比如说：一个方法，我只想让它执行10分钟，超过十分钟，就马上停止执行。执行了多少，未执行多少，就记录下它的执行状态即可。

今天，我就跟大家分享一个方案。

在这里：

1、使用JDK中提供的Callable和Future帮助实现；

2、使用Spring托管管理线程池；

3、控制方法执行10分钟，10分钟内执行完，正常返回；10分钟之外，报错超时，执行中断操作。

先看一段伪代码：

package com.creditease.monitor;

import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Service;

@Service
public class CheckService {
	
	/** 线程池 */
	@Autowired
	private ThreadPoolTaskExecutor taskExecutor;
	
	private final Logger logger = LoggerFactory.getLogger(CheckService.class);
	
	public void check(){
		
		CheckTask checkTask = new CheckTask();
		Future<String> futureTask = taskExecutor.submit(checkTask);
		
		try {
			futureTask.get(10, TimeUnit.MINUTES);
		} catch (InterruptedException e) {  
			//中断时的处理
			logger.error("执行了中断处理", e);
		} catch (ExecutionException e) {
			//方法报错
			logger.error("方法报错",e);
		} catch (TimeoutException e) {
			//超时
			logger.error("方法超时",e);
		}finally {
			
			//方法执行完时，设置中断
			futureTask.cancel(true);
		}
	}

	class CheckTask implements Callable<String>{

		@Override
		public String call() throws Exception {
			
			String strReturn = null;
			List<String> list = Arrays.asList("one","two","three","four","five","six","seven","eight");
			Iterator<String> iterator = list.iterator();
			
			//如果线程处于中断状态，则立即返回
			//TODO:do something more than 10mins
			while (iterator.hasNext() && !Thread.currentThread().isInterrupted()) {
				
				//TODO:do someting to get the result 'strReturn' 
				
				break;
			}
			return strReturn;
		}
	}
}

相应的线程池配置：

<bean id="taskExecutor"
	class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
		<!-- 核心线程数 -->
		<property name="corePoolSize" value="10" />
		<!-- 最大线程数 -->
		<property name="maxPoolSize" value="30" />
		<!-- 队列最大长度 >=mainExecutor.maxSize 默认为 Integer.MAX_VALUE-->
		<property name="queueCapacity" value="1000" />
		
		<!-- 线程池维护线程所允许的空闲时间 -->
		<property name="keepAliveSeconds" value="300" />
		<!-- 线程池对拒绝任务(无线程可用)的处理策略 -->
		<property name="rejectedExecutionHandler">
			<bean class="java.util.concurrent.ThreadPoolExecutor$CallerRunsPolicy" />
		</property>
	</bean>

分析一下：

在这段程序中，具体执行逻辑在CheckTask类中，线程池taskExecutor提交任务后，进入等待状态。

futureTask.get(10,TimeUnit.NINUTES)执行，获取执行结果时，主线程进入等待状态，具体执行逻辑的线程被唤醒执行逻辑。

如果执行逻辑10分钟内，成功获取到结果，那么方法正常返回；

如果方法执行，超过10分钟，则主线程被强制唤醒，并返回超时结果，即执行TimeoutException部分。

与此通知，注意与此同时：这时执行finally块儿中的futureTask.cancel(true)方法。这是主线程向执行逻辑线程发送中断信号。

注意：这时，在具体执行逻辑中，Thread.currentThread().isInterrupted()方法将变为true。也就是说，这是具体执行逻辑类的方法，也将终止执行并返回。

其实，这里就是我想跟大家分享的关键点：线程中断。

这里如果没有在finally块儿中，执行futureTask.cancel(true)，也就是这样：

//方法执行完时，设置中断
			//futureTask.cancel(true);

这样，执行结果将会如何呢？

很简单，如果超过十分钟，具体逻辑线程还未执行完的话，那么主线程依然会超时返回；而具体逻辑线程，则会将未执行完的任务执行完。也许是15分钟，也许是半个小时。也就是说，future.get()方法，能够保证一定时间内返回，但是Java中并没有给出一个线程kill掉另一个线程的方法。

注意：方法超时时，futureTask.get()并不能获取正常的结果返回了，这是Java中断机制所限制的，具体结果，可以通过其他方案弥补解决。

但是，Java提供了一种中断机制，需要开发人员辅助，来完成这个控制操作。

注意：如果在CheckTask类中，while逻辑循环中，存在 Thread.sleep()方法，以及wait()方法，那么我们就可以不使用中断机制了，也能达到线程中断的目的。原因就是，Java的线程中断机制中，执行线程收到中断信号，如果线程未处于**状态，就会线程就会被中断。