Thread_CallableAndFuture(线程池返回结果)

package com.gzhs.zsd.thread;

import java.util.Random;

import java.util.concurrent.Callable;

import java.util.concurrent.CompletionService;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.ExecutorCompletionService;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.Future;

/**

* 线程池Callable与Future应用

*/

public class Thread_CallableAndFuture {

public static void main(String[] args) {

//线程池提交一个任务, 返回结果测试
//Thread_getFuture();

//线程池提交一组任务, 返回结果测试
Thread_CompletionService();

}

//线程提交并拿到Future返回结果
public static void Thread_getFuture(){
//创建一个单独线程
ExecutorService thredPool =  Executors.newSingleThreadExecutor();
//线程池提交, 获取Future结果
Future<String> future =  thredPool.submit(new Callable<String>() {
@Override
public String call() throws Exception {
Thread.sleep(2000);
return "正常";
}
});

try {
System.out.println("等待检查结果： ");
System.out.println("拿到检查结果： " + future.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}

//线程池提交一组Callable任务, 采用take方法获取已完成的的一个Callable任务的Future结果
public static void Thread_CompletionService(){
//创建一个10个大小的线程池
ExecutorService threadPool = Executors.newFixedThreadPool(10);
//采用CompletionService提交一组任务
CompletionService<Integer> completionService = new ExecutorCompletionService<Integer>(threadPool);
//循环提交10个人任务
for(int i = 1; i <= 10; i++){
final int task = i;
completionService.submit(new Callable<Integer>() {
@Override
public Integer call() throws Exception {
//随机等待
Thread.sleep(new Random().nextInt(10000));
return task;
}
});
}

System.out.println("等待检查结果： ");
//循环拿结果
for(int i = 1; i<= 10; i++){
Future<Integer> future = null;
try {
//如果，这里没拿到结果, 会一直等待之后， 拿到结果之后， 在往下执行
future = completionService.take();
System.out.println("拿到检查结果： " + future.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}

}