java Future FutureTask 并发操作

摘要: 本文针对Future，进行了一系列操作，并对比Thread Runable两种线程实现方式

1.1 综述

创建线程有两种方式：extends Thread || inplements Runable，但是这两种方式都有一个缺陷，就是执行完任务后不能获取执行结果。
如果非要获取到执行结果的话，就必须通过共享变量或者是线程通信的方法来达到效果，使用较为麻烦，为了解决这种问题，java提供了Callable Future ，通过他们可以再任务执行完毕后得到任务执行结果。

1.2 Runable Callable 对比

java.lang.Runable是一个接口，声明了run()方法：

public interface Runable {
public abstract void run();
}

因为run()方法返回值void，所以执行完任务后不能返回结果。

java.util,concurrent.Callable 也是一个接口，里面声明了一个方法call();

public interface Callable<V> {
V call() throws Exception;
}

call{}函数返回的类型就是这个传递进来的V类型，使用Callable 就需要配合ExecutorService配合使用：

<T> Future<T> submit(Callable<T> task);
<T> Future<T> submit(Runnable task, T result);
Future<?> submit(Runnable task);

1.3 Future 接口 方法含义

Future类位于java.util.concurrent包下，它是一个接口

public interface Future<V> {
boolean cancel(boolean mayInterruptIfRunning);
boolean isCancelled();
boolean isDone();
V get()
throws InterruptedException, ExecutionException;
V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException;
}

cancel方法用来取消任务，如果取消任务成功则返回true，如果取消任务失败则返回false。参数mayInterruptIfRunning表示是否允许取消正在执行却没有执行完毕的任务，如果设置true，则表示可以取消正在执行过程中的任务。如果任务已经完成，则无论mayInterruptIfRunning为true还是false，此方法肯定返回false，即如果取消已经完成的任务会返回false；如果任务正在执行，若mayInterruptIfRunning设置为true，则返回true，若mayInterruptIfRunning设置为false，则返回false；如果任务还没有执行，则无论mayInterruptIfRunning为true还是false，肯定返回true。
isCancelled方法表示任务是否被取消成功，如果在任务正常完成前被取消成功，则返回 true。
isDone方法表示任务是否已经完成，若任务完成，则返回true；
get()方法用来获取执行结果，这个方法会产生阻塞，会一直等到任务执行完毕才返回；
get(long timeout, TimeUnit unit)用来获取执行结果，如果在指定时间内，还没获取到结果，就直接返回null。

1.4 Future FutureTask 相关

因为Future只是一个接口，所以是无法直接用来创建对象使用的，因此就有了下面的FutureTask。
FutureTask是Future接口的一个唯一实现类。

public class FutureTask<V> implements RunnableFuture<V>

public interface RunnableFuture<V> extends Runnable, Future<V> {
void run();
}

FutureTask提供了2个构造器：

public FutureTask(Callable<V> callable) {
}
public FutureTask(Runnable runnable, V result) {
}

1.5 代码示例

示例

package com.test.java.future;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Test {
public static void main(String[] args) {
ExecutorService executor = Executors. newCachedThreadPool();
Task task = new Task();
Future<Integer> result = executor.submit(task);
executor.shutdown();

try {
Thread. sleep(1000);
} catch (InterruptedException e1) {
e1.printStackTrace();
}

System. out.println("主线程在执行任务" );

try {
System. out.println("task运行结果" + result.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}

System. out.println("所有任务执行完毕" );
}
}

class Task implements Callable<Integer> {
@Override
public Integer call() throws Exception {
System. out.println("子线程在进行计算" );
Thread. sleep(3000);
int sum = 0;
for (int i = 0; i < 100; i++)
sum += i;
return sum;
}
}

package com.test.java.future;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;

public class Test1 {
public static void main(String[] args) {
// 第一种方式
ExecutorService executor = Executors. newCachedThreadPool();
Task1 task = new Task1();
FutureTask<Integer> futureTask = new FutureTask<Integer>(task);
executor.submit(futureTask);
executor.shutdown();

// 第二种方式，注意这种方式和第一种方式效果是类似的，只不过一个使用的是ExecutorService，一个使用的是Thread
/*
* Task task = new Task(); FutureTask<Integer> futureTask = new
* FutureTask<Integer>(task); Thread thread = new Thread(futureTask);
* thread.start();
*/

try {
Thread. sleep(1000);
} catch (InterruptedException e1) {
e1.printStackTrace();
}

System. out.println("主线程在执行任务" );

try {
System. out.println("task运行结果" + futureTask.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}

System. out.println("所有任务执行完毕" );
}
}

class Task1 implements Callable<Integer> {
@Override
public Integer call() throws Exception {
System. out.println("子线程在进行计算" );
Thread. sleep(3000);
int sum = 0;
for (int i = 0; i < 100; i++)
sum += i;
return sum;
}
}

1.6 另外一个恰当的示例说明

举个简单的例子：当你在网上购物时，如果付款成功了，你是否立即拿到了你买到的商品？当然不是，当你付款成功时，你得到的仅仅是一个，订单提交成功的提示而已，其它的什么都没了，从这一刻开始，你是否会一直呆在家里，什么都不做，直到你的商品送到你手中呢？当然也不是，当你订单提交成功后，你会去做你该做的，当你的商品送到时，你只需签收一下即可，从订单提交到商品送到之间，你不会因为等待商品送到而耽误你的时间，你可以自由支配你的时间，好像什么都没有发生一样。
是的，Future模式就是这个意思
当客户提交一个请求时，这个请求有可能会花很长一段时间去处理后台数据，之后，再返回给客户一个处理过的数据，那这段时间，客户一直在等待服务端的响应，是不是会让客户觉得很厌烦呢？当然会了，所以Future模式就是为了提高响应时间而诞生的，当然这个提高其实是一个假象。当客户提交一个请求时，我们让客户立即返回一个虚拟的数据响应，之后，客户端就不用为了等待响应而无事可做了，此后，客户端可以进行别的任何操作，当真正的数据处理完返回给客户了，客户再去进行相应的处理，这样就会让客户没有无谓的等待了.

package com.test.java.future;

import java.util.concurrent.Callable;

public class MyData implements Callable<String> {

private String myStr ;

public MyData(String myStr) {
this .myStr = myStr;
}

@Override
public String call() throws Exception {
StringBuffer sb = new StringBuffer();
for (int i=0;i<10;i++) {
sb.append( myStr);
try {
Thread. sleep(1000);
} catch (Exception e) {
e.printStackTrace();
}
}
return sb.toString();
}

}

package com.test.java.future;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;

public class MyDataTest {

public static void main(String[] args) {
FutureTask<String> future = new FutureTask<String>( newMyData("alexgaoyh" ));
ExecutorService exe = Executors. newFixedThreadPool(1);
exe.submit(future);
exe.shutdown();
System. out .println("客户端请求结束了" );
System. out .println("任务是否已经完成：" +future.isDone());
try {
/*
* 这段时间，就是后台在获取真正数据的时间
*/
System. out .println("在这段时间，我可以做我自己的事情" );
System. out .println("真正的数据:" +future.get());
System. out .println("任务是否已经完成：" +future.isDone());
} catch (Exception e) {
e.printStackTrace();
}
}

}