quartz执行卡死--强制中断线程

在quartz中经常会碰到由于网络问题或者一些其他不稳定因素导致的线程卡死问题，这往往会导致数据处理的延时。而有时候一时无法定位到卡死的原因，为了降低系统风险，我们就会希望有一个超时机制，当执行超时时强制中断该操作。下面就举个例子，ftp协议不稳定，当连接ftp上传下载数据时有时候会遇到不可知的因素会导致卡死，比如说主动被动切换，服务器连接数满等等，现在我们使用java提供的动态代理以及Future的超时机制来解决延时问题。代码如下：

public class FtpClientProxy implements InvocationHandler  {
    private static ExecutorService executor = Executors.newCachedThreadPool();
    private FtpClient target;
    private static String interceptorNames="uploadFile,chdir,listFiles,downloadFile,existDir,mkdir,rename";
    private static final  String THREAD_TIMEOUT_CONFIG="THREAD_TIMEOUT_CONFIG";
    private static final  String METHOD_INTERCEPTOR_CONFIG="METHOD_INTERCEPTOR_CONFIG";
    private static int threadTimeout=7200;
    private static final Logger logger=Logger.getLogger(FtpClientProxy.class);

    /**
     * 创建一个新的实例 FtpClientProxy.
     */
    public FtpClientProxy() {
        try {
            String timeoutConfig=UspcUtil.getSysConfigValue(THREAD_TIMEOUT_CONFIG);
            if(StringUtils.isNotBlank(timeoutConfig)){
                threadTimeout=Integer.parseInt(timeoutConfig);
            }
            interceptorNames=UspcUtil.getSysConfigValue(METHOD_INTERCEPTOR_CONFIG);
        } catch (Exception e) {
            logger.error("获取超时配置THREAD_TIMEOUT_CONFIG出错",e);
        }

    }

    /**
     * @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[])
     */
    @Override
    public Object invoke(Object proxy, final Method method, final Object[] args) throws Throwable {
        Object result = null;
        String methodName=method.getName();
        if(StringUtils.isNotBlank(interceptorNames)&&interceptorNames.contains(methodName)){

            Future<Object> future = executor.submit(new Callable<Object>() {

                @Override
                public Object call() throws Exception {
                    logger.debug(method.getName()+"代理方法执行开始");
                    return method.invoke(target, args);
                }
            });
            try {
                result = future.get(threadTimeout, TimeUnit.SECONDS);
                logger.debug(methodName+"代理方法执行结束");
            } catch (TimeoutException e) {
                logger.error("执行方法"+methodName+"超时",e);
                future.cancel(true);
                throw new Exception("执行方法"+methodName+"超时");
            } catch (Exception e) {
                future.cancel(true);// 中断执行此任务的线程
                throw new Exception(e);
            }
        }else{
            result=method.invoke(target, args);
        }
        return result;
    }

    /**
     * 绑定委托对象并返回一个代理类
     *
     * @param target
     * @return
     */
    public FtpClient bind(FtpClient target) {
        this.target = target;
        // 取得代理对象
        return (FtpClient) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass()
                .getInterfaces(), this);
    }
}

可以按照配置的时间来进行超时判断，也可以配置拦截的方法。