Future与FutureTask区别

笨鸟不会飞的

已于 2022-07-27 14:59:41 修改

阅读量140

点赞数 1

分类专栏：多线程文章标签： java

于 2022-07-27 13:30:16 首次发布

本文链接：https://blog.youkuaiyun.com/weixin_43932663/article/details/126012568

版权

多线程专栏收录该内容

1 篇文章

订阅专栏

本文探讨了Java中的Future接口与FutureTask类的区别。Future是一个接口，而FutureTask不仅实现了Future接口，还继承了Runnable接口，允许它作为线程执行的任务。文章通过实例解释了如何使用FutureTask进行异步计算。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Shift+Ctrl+Alt+u 生成

Future是一个接口

 boolean cancel(boolean mayInterruptIfRunning);
 boolean isCancelled();
 boolean isDone();
 get() throws InterruptedException, ExecutionException;
 get(long timeout, TimeUnit unit);
 throws InterruptedException, ExecutionException, TimeoutException;

RunnableFuture 接口继承了Runnable, Future 接口
FutureTask 实现了RunnableFuture接口

	public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;       // ensure visibility of callable
    }
 	public boolean cancel(boolean mayInterruptIfRunning) {
        if (!(state == NEW &&
              UNSAFE.compareAndSwapInt(this, stateOffset, NEW,
                  mayInterruptIfRunning ? INTERRUPTING : CANCELLED)))
            return false;
        try {    // in case call to interrupt throws exception
            if (mayInterruptIfRunning) {
                try {
                    Thread t = runner;
                    if (t != null)
                        t.interrupt();
                } finally { // final state
                    UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED);
                }
            }
        } finally {
            finishCompletion();
        }
        return true;
    }
	public boolean isCancelled() {
	    return state >= CANCELLED;
	}
 	public boolean isDone() {
        return state != NEW;
    }
	public V get() throws InterruptedException, ExecutionException {
	        int s = state;
	        if (s <= COMPLETING)
	            s = awaitDone(false, 0L);
	        return report(s);
    }
     /**
     * @throws CancellationException {@inheritDoc}
     */
    public V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException {
        if (unit == null)
            throw new NullPointerException();
        int s = state;
        if (s <= COMPLETING &&
            (s = awaitDone(true, unit.toNanos(timeout))) <= COMPLETING)
            throw new TimeoutException();
        return report(s);
    }

FutureTask使用

List<Future<Map<Integer, List<CoreCommissionIncomeDetail>>>> futureTaskList = new ArrayList<>();
        final ExecutorService executorService = Executors.newFixedThreadPool(5);
        for (int i=0; i<= vo.getCountTotal()/shardingCount; i++) {
            final int finalI = i;
            if ((i + 1) * shardingCount > vo.getCountTotal()) {
            	//分页查询sql
                objectQueryWrapper.orderByDesc("id").last("limit\t"+i * shardingCount+","+ vo.getCountTotal());
            } else {
                objectQueryWrapper.orderByDesc("id").last("limit\t"+i * shardingCount+","+shardingCount*(i+1));
            }
            //异步执行
            Callable<Map<Integer, List<CoreCommissionIncomeDetail>>> queryCall = new Callable<Map<Integer, List<CoreCommissionIncomeDetail>>>() {
                @Override
                public Map<Integer, List<CoreCommissionIncomeDetail>> call() throws Exception {
                    Map<Integer, List<CoreCommissionIncomeDetail>> subResultMap = new TreeMap<>();
                    subResultMap.put(finalI, coreCommissionIncomeDetailService.list(objectQueryWrapper));
                    return subResultMap;
                }
            };
            //添加到task中,执行查询
            FutureTask<Map<Integer, List<CoreCommissionIncomeDetail>>> futureTas =  new FutureTask<>(queryCall);
            futureTaskList.add(futureTas);
            //执行查询
            executorService.submit(futureTas);
        }
        //待所有查询完毕后，再进行顺序汇总
        Map<Integer, List<CoreCommissionIncomeDetail>> resultMap = new TreeMap<Integer, List<CoreCommissionIncomeDetail>>();
        //将循环集合放入Map中
        for (Future<Map<Integer, List<CoreCommissionIncomeDetail>>> futureTask : futureTaskList) {
            try {
                Map<Integer, List<CoreCommissionIncomeDetail>> integerListMap = futureTask.get();
                resultMap.putAll(integerListMap);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        System.err.println("总共耗时：" + (System.currentTimeMillis() - start) / 1000);
        Set<Integer> mapKeys = resultMap.keySet();//获取所有几个的
        List<CoreCommissionIncomeDetail> resultList = new ArrayList<>();
        for (Integer mapItem : mapKeys) {
            resultList.addAll(resultMap.get(mapItem));
        }