线程池工具类实现结束指定线程

1.工具类基类（配置类）：ExecutorSchdule

public interface ExecutorSchdule {

    //corePoolSize 表示允许线程池中允许同时运行的最大线程数。
    int corePoolSize = 40;
    
    //maximumPoolSize最大能创建多少个线程
    int maximumPoolSize  = 50;
    
    //keepAliveTime表示线程没有任务时最多保持多久然后停止
    long keepAliveTime = 4L;
    
    //keepAliveTime的时间单位
    TimeUnit unit = TimeUnit.SECONDS;
    
    //workQueue存放超出线程池数以后的多余线程
    BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<Runnable>(maximumPoolSize);

}

2.工具类实现：TaskExecutorUtil

/**
 * 
 * 线程池工具类
 * @author HUAWEI
 *
 */
public class TaskExecutorUtil implements ExecutorSchdule {
    
    //临时存放任务的注册表
    private static Map<String, Future<Object>> localcache = new ConcurrentHashMap<String, Future<Object>>();
    
    private static ExecutorService executer = null;
    
    private static TaskExecutorUtil executor = null;
    
    
    //单例同步
    public static TaskExecutorUtil getInstance(){
        synchronized (TaskExecutorUtil.class) {
            if(executer == null){
                executer = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
            }
            if(executor == null){
                executor = new TaskExecutorUtil();
            }
        }
        return executor;
    }

    //添加指定任务到线程池，并提交
    public void run(Callable<Object> caller,String taskname){
        if(taskname==null||StringUtils.isEmpty(taskname))
            return;
        Future<Object> future = executer.submit(caller);
        localcache.put(taskname, future);
    }
    //移除指定线程池任务
    public boolean removetask(String taskname){
        Future<Object> future = localcache.get(taskname);
        if(future != null){
            future.cancel(true);
            localcache.remove(taskname);
        }
        return future.isCancelled();
    }
    
    //关闭线程池
    public void shutdown(){
        executer.shutdown();
    }
    
    //移除所有线程池任务
    public void removealltask(){
        for(String taskname:localcache.keySet()){
            Future<Object> future = localcache.get(taskname);
            future.cancel(true);
        }
        localcache.clear();
    }
    
    //获取提交线程的执行结果
    public Object get(String taskname){
        Object res = null;
        Future<Object> future = localcache.get(taskname);
        try {
            if(future != null)
                res = future.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        return res;
    }
}

3.测试类：test

public class test {
    /**
     * 在每个线程池执行run()之间添加输出为了验证主线程没有被阻塞
     * return语句不同返回为了验证返回对象的不确定性
     * 考虑到线程可能被取消执行，这里引入执行结束正常退出操作和被Interrupt时结束正在执行的任务
     * @param args
     */
    class User{
        private String name;
        public User setName(String name){
            this.name = name;
            return this;
        }
        public String getName(){
            return name;
        }
    }
public static void main(String[] args) {
    TaskExecutorUtil executor = TaskExecutorUtil.getInstance();
    executor.run(new Callable<Object>() {
        
        @Override
        public Object call() throws Exception {
            // TODO Auto-generated method stub
            Thread.currentThread().sleep(2*1000);
            return 2+1;
        }
    }, "add");
    System.out.println("hihihi");
    executor.run(new Callable<Object>() {
            @Override
            public Object call() throws Exception {
                boolean exit = false;
                int sum = 0;
                while(!exit&&!Thread.currentThread().isInterrupted()){
                    try{
                        Thread.currentThread().sleep(2*1000);
                        sum = 2-1;
                    }catch (InterruptedException e) {
                        e.printStackTrace();
                        break;
                    }
                }
                return sum;
            }
        }, "sub");
    System.out.println("hihihi");
    executor.run(new Callable<Object>() {
        
        @Override
        public Object call() throws Exception {
            // TODO Auto-generated method stub
            boolean exit = false;
            User user = null;
            while(!exit&&!Thread.currentThread().isInterrupted()){
                try{
                    test t = new test();
                    Thread.currentThread().sleep(2*1000);
                    user = t.new User().setName("大圣");
                    exit = true;
                }catch (InterruptedException e) {
                    e.printStackTrace();
                    break;
                }
            }
            return user;
        }
    }, "mut");
    System.out.println("hihihi");
    executor.run(new Callable<Object>() {
        
        @Override
        public Object call() throws Exception {
            // TODO Auto-generated method stub
            Thread.currentThread().sleep(2*1000);
            return 2/1;
        }
    }, "div");
    System.out.println("hihihi");
    executor.removetask("sub");
//    executor.removealltask();
    System.out.println("addoper result:"+executor.get("add"));
    System.out.println("suboper result:"+executor.get("sub"));
    User u = (User)executor.get("mut");
    System.out.println("mutoper result:"+u.getName());
    System.out.println("divoper result:"+executor.get("div"));
}
}

3.1.移除指定线程执行截图：

 3.2.移除所有任务时截图：

 4.运行结果分析：

对于输出3.1，由于使用了异常处理，名为sub的线程睡眠被interrupted，故抛出异常，后续输出也能正常进行

对于输出3.2，由于名为mut和sub的线程都被正常处理过，sleep操作抛出异常，但结果仍然可访问，但名为add和的线程未进行任何处理，被interrupt后call方法无返回，故get方法就会报错。

5.写在最后：

以上都是本人的测试用例，工具类存在的问题还请大神尽量多的指出，谢谢