futuretask java 并发请求_java Future FutureTask 并发操作

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 call() throws Exception;

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

Future submit(Callable task);

Future submit(Runnable task, T result);

Future> submit(Runnable task);

1.3 Future 接口 方法含义

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

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;

}

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 implements RunnableFuture

public interface RunnableFuture extends Runnable, Future {

void run();

}

FutureTask提供了2个构造器：

public FutureTask(Callable 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 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 {

@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 futureTask = new FutureTask(task);

executor.submit(futureTask);

executor.shutdown();

// 第二种方式，注意这种方式和第一种方式效果是类似的，只不过一个使用的是ExecutorService，一个使用的是Thread

/*

* Task task = new Task(); FutureTask futureTask = new

* FutureTask(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 {

@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 {

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 future = new FutureTask( 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();

}

}

}