上篇介绍了创建线程的前两种方式，继承Thread和实现Runnable接口，但它两都有个天生的缺陷，就是没有返回值。执行了半天没有返回值，这可咋整？
其实，如果要有返回值也是有方法的。java提供了Callable接口、Future接口、FutureTask接口，通过使用它们就能在线程执行完得到返回结果，话不多说，试一把就知道了
public class Test3 {
public static void main(String[] args) {
//创建一个有5个固定线程的线程池
ExecutorService executorService = Executors.newFixedThreadPool(5);
try {
Future run = executorService.submit(new Runnable() {
@Override
public void run() {
System.out.println("哈哈哈哈哈哈");
}
});
System.out.println("run的返回值："+run.get());
}catch (Exception e) {
e.printStackTrace();
}
executorService.shutdown();
}
}
执行结果：Runnable无返回值
public class Test3 {
public static void main(String[] args) {
//创建一个有5个固定线程的线程池
ExecutorService executorService = Executors.newFixedThreadPool(5);
try {
Future future = executorService.submit(new Callable() {
@Override
public String call() throws Exception {
System.out.println("呵呵呵呵呵");
return "呵呵呵呵呵";
}
});
System.out.println("future的执行结果："+future.get());
}catch (Exception e) {
e.printStackTrace();
}
executorService.shutdown();
}
}
执行结果：Callable是有返回值的
上面的两个小例子可以就看出Runnable和Callable的本质区别就是有无返回值，其中使用了Future接口，ExecutorService接口，下面介绍下这些接口：
Callable
public interface Callable {
V call() throws Exception;
}
接口Callable中只声明了一个方法call(),返回类型就是V,当然光使用一个Callable还不能获取返回值，还需要ExecutorService、Future一起使用（Callable、ExecutorService、Future均属于JUC包下，而Runnable属于java.lang包下）
public interface ExecutorService extends Executor {
//方法省略
}
Future
public interface Future {
boolean cancel(boolean mayInterruptIfRunning);
boolean isCancelled();
boolean isDone();
V get() throws InterruptedException, ExecutionException;
V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException;
}
Future 表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并获取计算的结果。计算完成后只能使用 get 方法来获取结果，如有必要，计算完成前可以阻塞此方法。
方法介绍：
cancel用来取消任务，如果取消成功返回true,取消失败返回false，mayInterruptIfRunning的意思是是否取消执行一半没有执行完毕的任务。若mayInterruptIfRunning设为true,则表示能够强制取消执行一半的任务，如果被取消任务还没完成，返回true,如果被取消任务已完成，返回false;若mayInterruptIfRunning设为false,若果任务没完成，返回false,如果任务已完成，返回false(任务完成，不管mayInterruptIfRunning设成啥，都返回false;任务没开始，不管mayInterruptIfRunning设成啥，都返回true)。
isCancelled用来表示任务是否被成功取消，如果成功，返回true。
isDone用来表示任务是否成功完成，如果成功，返回true。
get()用来获取返回值，这是个阻塞方法，会等任务执行完毕再返回。
**get(long timeout, TimeUnit unit)也是用来获取返回值，比上一个聪明点，如果在设定时间内任务还没完成，就返回null。
public class Test3 {
public static void main(String[] args) {
//创建一个有5个固定线程的线程池
ExecutorService executorService = Executors.newFixedThreadPool(5);
try {
Future future2 = executorService.submit(new Callable() {
@Override
public String call() throws Exception {
try {
while(true){
System.out.println("task2 running");
Thread.sleep(500);
}
}catch (Exception e){
System.out.println("Interrupted task2.");
}
return "嘻嘻嘻嘻嘻";
}
});
Thread.sleep(3000);
System.out.println("task2 cancel:" + future2.cancel(true));
}catch (Exception e){
e.printStackTrace();
}
executorService.shutdown();
}
}
可以看到任务future2于主线程异步执行，主线程sleep3秒钟，停止任务，停止任务成功。
FutureTask
FutureTask
Runnable,Future
有两个构造方法：
public class Test4 {
public static void main(String[] args) {
Random random = new Random();
Callable task = new Callable() {
@Override
public Integer call() throws Exception {
return random.nextInt(100);
}
};
FutureTask futureTask1 = new FutureTask(task);
Thread thread = new Thread(futureTask1);
thread.start();
try {
System.out.println("用Thread执行的结果为："+futureTask1.get());
System.out.println("下面准备使用Executors执行");
Thread.sleep(1000);
} catch (Exception e) {
e.printStackTrace();
}
FutureTask futureTask2 = new FutureTask(task);
ExecutorService executorService = Executors.newFixedThreadPool(2);
executorService.submit(futureTask2);
try {
System.out.println("用Executors执行的结果为:"+futureTask2.get());
} catch (Exception e) {
e.printStackTrace();
}
executorService.shutdown();
}
}
小结
此篇主要介绍了使用Callable接口创建有返回结果的线程，其中涉及到了Future、FutureTask、ExecutorService等接口的使用。Future单词本身含义为将来，在程序中的意思应该就是提交一个请求后，不用傻等着结果返回，可以先做别的操作，等返回结果真正处理完成并返回给请求方后，请求方再做相应处理。
略陈固陋，如有不当之处，欢迎各位看官批评指正！