JAVA 线程池：超时等待线程调用

Executors.newSingleThreadExecutor()

只有一个线程，无任务暂缓线程

Executors.newFixedThreadPool()

固定线程数量，无任务暂缓线程

Executors.newCachedThreadPool()

根据内存情况调整线程个数，不限制线程个数（可能会OOM），线程空闲60秒自动回收

Executors.newScheduledThreadPool()

返回ScheduledExecutorService对象

应用newFixedThreadPool()

/**
 * Created by hurf on 2016/8/24.
 * 多线程帮助类
 */
public class ThreadsUtil {
    public static ExecutorService executor = Executors.newFixedThreadPool(12);//几个内核就初始化几个
        /**
     * 统一超时调用入口
     * @param callable
     * @return 
     *     调用实例：
     *     String result = ThreadsUtil.execInTime(new CallableImpl("入参"));
     *     class CallableImpl implements Callable { private String key = ""; public CallableImpl(String key) {this.key = key;} ...}
     */
    public static  T execInTime(Callable callable) {
        Future future = executor.submit(callable);
        T t = null;
        try {
            t = future.get(CallAtomUtil.timeOutLen, TimeUnit.MILLISECONDS);
        } catch (InterruptedException e) {
            String cuase = ObjectUtils.toString(e.getCause()).replace(toReplaceStr,"，");
            String eMsg = "等待远程调用结果时被中断,详细情况如下：【"+cuase+"】";
            LogUtil.error(eMsg);
            future.cancel(true);
            throw new AtomException(-6787,eMsg, FrameworkConstants.BIZ_LVL);
        } catch (ExecutionException e) {
            String cuase = ObjectUtils.toString(e.getCause()).replace(toReplaceStr,"，");
            String eMsg = "远程调用异常,详细情况如下：【"+cuase+"】";
            LogUtil.error(eMsg);
            future.cancel(true);
            throw new AtomException(-6787,eMsg, FrameworkConstants.BIZ_LVL);
        } catch (TimeoutException e) {
            String eMsg = "等待远程调用结果超时";
            LogUtil.error(eMsg);
            future.cancel(true);
            throw new AtomException(-6789, eMsg, FrameworkConstants.BIZ_LVL);
        }
        return t;
    }

    /**
     * 超时调用重载
     * @param callable
     * @param timeOut 毫秒超时30000 就是30秒
     * @param 
     * @return
     */
    public static  T execInTime(Callable callable,long timeOut){
        Future future = executor.submit(callable);
        T t = null;
        try {
            t = future.get(timeOut, TimeUnit.MILLISECONDS);
        } catch (InterruptedException e) {
            String cuase = ObjectUtils.toString(e.getCause()).replace(toReplaceStr,"，");
            String eMsg = "等待远程调用结果时被中断,详细情况如下：【"+cuase+"】";
            LogUtil.error(eMsg);
            future.cancel(true);
            throw new AtomException(-6787,eMsg, FrameworkConstants.BIZ_LVL);
        } catch (ExecutionException e) {
            String cuase = ObjectUtils.toString(e.getCause()).replace(toReplaceStr,"，");
            String eMsg = "远程调用异常,详细情况如下：【"+cuase+"】";
            LogUtil.error(eMsg);
            future.cancel(true);
            throw new AtomException(-6787,eMsg, FrameworkConstants.BIZ_LVL);
        } catch (TimeoutException e) {
            String eMsg = "等待远程调用结果超时";
            LogUtil.error(eMsg);
            future.cancel(true);
            throw new AtomException(-6789, eMsg, FrameworkConstants.BIZ_LVL);
        }
        return t;
    }

    /**
     * 不限时执行
     * @param callable
     * @param 
     * @return
     */
    public static  T exec(Callable callable){
        Future future = executor.submit(callable);
        T t = null;
        try {
            t = future.get();
        } catch (InterruptedException e) {
            String cuase = ObjectUtils.toString(e.getCause()).replace(toReplaceStr,"，");
            String eMsg = "等待远程调用结果时被中断,详细情况如下：【"+cuase+"】";
            LogUtil.error(eMsg);
            future.cancel(true);
            throw new AtomException(-6787,eMsg, FrameworkConstants.BIZ_LVL);
        } catch (ExecutionException e) {
            String cuase = ObjectUtils.toString(e.getCause()).replace(toReplaceStr,"，");
            String eMsg = "远程调用异常,详细情况如下：【"+cuase+"】";
            LogUtil.error(eMsg);
            future.cancel(true);
            throw new AtomException(-6787,eMsg, FrameworkConstants.BIZ_LVL);
        }
        return t;
    }

    /**
     * 用于监控数据库的线程执行入口
     * @param callable
     * @param 
     * @return
     */
    public static  T lookDb(Callable callable){
        if("1".equals(CallAtomUtil.remoteCallTimeOutFlag)){
            long timeOut = CallAtomUtil.timeOutLen+10000;
            return execInTime(callable,timeOut);
        }else {
            return exec(callable);
        }
    }
}

调用

List