我们在一个接口中做了多个事情,但是又需要一个统一返回,并且这些事情没有相关性的时候,我们就可以使用future,比如我一遍煮饭一边炒菜,等饭煮好,菜炒好然后叫大家吃饭。这样的一个场景我们就可以使用future来处理,如果锅只有一个这个就没办法了,只能按顺序执行,饭煮好了锅才能腾出来炒菜哈。
用上future有什么好处呢?当然是为了充分利用时间,比如你炒菜5分钟,煮饭10分钟,如果你是顺序执行,那么你就得花15分钟完成这件事,但是如果你并行去做这两件事情却只要10分钟。
再举个实际场景得例子,我有一个商品需要处理它得不同维度得数据,店铺,商家,商品,仓库、品牌、客户这些信息,每个信息得处理都是又臭又长,那么这个时候,最节省时间得方式就是并行去处理这些信息。所以就可以构建程序如下
任务抽线类Task.java
package com.qimo.task;
import java.util.concurrent.Callable;
/**
* @Description TODO
* @Author 姚仲杰
* @Date 2021/11/3 9:33
*/
public abstract class Task implements Callable<Long> {
/**
* 业务实现
*/
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;
/**
* @Description TODO
* @Author 姚仲杰
* @Date 2021/11/3 9:35
*/
public class TaskExecutor {
Logger logger = LoggerFactory.getLogger(TaskExecutor.class);
private Collection<Callable<Long>> tasks = new ArrayList<>();
public void addTasks(Callable<Long> callable) {
tasks.add(callable);
}
public void execute() {
try {
long start = System.currentTimeMillis();
List<Future<Long>> futures = null;
futures = ThreadPool.getExecutorService().invokeAll(tasks);
long result = 0;
for (Future<Long> 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;
/**
* @Description TODO
* @Author 姚仲杰
* @Date 2021/11/3 14:14
*/
public class ThreadPool {
private static final ExecutorService executorService = new ThreadPoolExecutor(
6,
6,
60,
TimeUnit.SECONDS,
new LinkedBlockingQueue<Runnable>(200),
new ThreadPoolExecutor.CallerRunsPolicy());
public static ExecutorService getExecutorService(){
return executorService;
}
}
task实现,当然后面还有其它得商品,店铺,商家等信息得处理就省略了,内容一致
package com.qimo.task;
import com.qimo.task.Task;
/**
* @Description TODO
* @Author 姚仲杰
* @Date 2021/11/2 13:44
*/
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秒即可完成。当然实际结果会多一点点。