一文搞懂Future的作用

我们在一个接口中做了多个事情，但是又需要一个统一返回，并且这些事情没有相关性的时候，我们就可以使用future，比如我一遍煮饭一边炒菜，等饭煮好，菜炒好然后叫大家吃饭。这样的一个场景我们就可以使用future来处理，如果锅只有一个这个就没办法了，只能按顺序执行，饭煮好了锅才能腾出来炒菜哈。
用上future有什么好处呢？当然是为了充分利用时间，比如你炒菜5分钟，煮饭10分钟，如果你是顺序执行，那么你就得花15分钟完成这件事，但是如果你并行去做这两件事情却只要10分钟。

再举个实际场景得例子，我有一个商品需要处理它得不同维度得数据，店铺，商家，商品，仓库、品牌、客户这些信息，每个信息得处理都是又臭又长，那么这个时候，最节省时间得方式就是并行去处理这些信息。所以就可以构建程序如下
任务抽线类Task.java

package com.qimo.task;

import java.util.concurrent.Callable;


public abstract class Task implements Callable {
    
    
    public abstract void process();
    
    @Override
    public Long call() throws Exception {
        long start = System.currentTimeMillis();
        process();
        long end=System.currentTimeMillis();
        return end-start;
    }
}

构建任务执行器

package com.qimo.task;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


public class TaskExecutor {
    Logger logger = LoggerFactory.getLogger(TaskExecutor.class);
    private Collection> tasks = new ArrayList<>(); 
    public void addTasks(Callable callable) {
        tasks.add(callable);
    }
    public void execute() {
        try {
            long start = System.currentTimeMillis();
            List> futures = null;
            futures = ThreadPool.getExecutorService().invokeAll(tasks);
            long result = 0;
            for (Future future : futures) {
                result += future.get();
            }
            long end = System.currentTimeMillis();
            logger.info("任务执行总耗时：{}ms,任务累计耗时{}ms", end - start, result);
        } catch (InterruptedException e) {
            logger.error("任务执行异常",e);
        } catch (ExecutionException e) {
            logger.error("任务执行异常",e);
        } finally {
            ThreadPool.getExecutorService().shutdown();
        }
    }
    
}

构建线程池

package com.qimo.task;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.linkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;


public class ThreadPool {
    private static final ExecutorService executorService = new ThreadPoolExecutor(
        6,
        6,
        60,
        TimeUnit.SECONDS,
        new linkedBlockingQueue(200),
        new ThreadPoolExecutor.CallerRunsPolicy());
    
    public static ExecutorService getExecutorService(){
        return executorService;
    }
}

task实现,当然后面还有其它得商品，店铺，商家等信息得处理就省略了，内容一致

package com.qimo.task;

import com.qimo.task.Task;


public class BrandDataTask extends Task {
    
    @Override
    public void process() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("BrandDataTask ");
    }
}

这里假设一个业务处理了1秒中，如果按正常顺序处理，这里需要花6秒中执行完这个业务，用上future之后只需要1秒即可完成。当然实际结果会多一点点。