futuretask java 并发请求_Java并发：Callable异步回调Future、FutureTask用法

简单说明：

Callable接口类似于Runnable，但是Runnable不会返回结果，并且无法抛出返回结果的异常，而Callable功能更强大一些，被线程执行后，可以返回值，这个返回值可以被Future拿到。

FutureTask实现了两个接口，Runnable和Future，所以它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值。假设有一个很耗时的返回值需要计算，并且这个返回值不是立刻需要的话，那么就可以使用这个组合，用另一个线程去计算返回值，而当前线程在使用这个返回值之前可以做其它的操作，等到需要这个返回值时，再通过Future得到。

Callable说明：

Callbale接口是一个参数化的类型，只有一个方法call。

public interface Callable

{

V call() throw Exception;

}

类型参数是返回值的类型。例如，Callable表示一个最终返回Integer的异步计算。

Future用法:

java.util.concurrent.Future 是一个异步回调接口，保存异步计算的结果。

Future接口具有下面方法：

public interface Future

{

V get() throws ...;

V get(long timeout, TimeUnit unit) throws ...;

void cancel(boolean mayInterrupt);

boolean isCancelled();

boolean isDone();

}

用例：

public class CallableFuture {

public static void main(String[] args) throws InterruptedException, Exception {

ExecutorService exec = Executors.newCachedThreadPool();

// Future是一个接口，该接口用来返回异步的结果。

Future st = exec.submit(new TaskCallable());

System.out.println("finished");

}

}

class TaskCallable implements Callable {

public String call() throws Exception {

Thread.sleep(2000);

return "callstatus=OK";

}

}

java.util.concurrent.Future

V get()

V get(long time, TimeUnit unit)

获取结果，如果没有结果可用，则阻塞直到真正得到结果超过指定的时间为止。如果不成功，第二个方法会抛出TimeoutException异常。

boolean cancel(boolean mayInterrupt)

尝试取消一任务的运行。如果任务已经开始，并且mayInterrupt参数值为true，它就会被中断。如果成功执行了取消操作，返回true。

boolean isCancelled()

如果任务在完成前被取消了，则返回true。

boolean isDone()

如果任务结束，无论是正常结束、中途取消或发生异常，都返回true。

FutureTask用法：

FutureTask实现了java.util.concurrent.RunnableFuture接口，实际上实现了Runnable和 Future两个接口。

java.util.concurrent.FutureTask

FutureTask(Callable task)

FutureTask(Runnable task, V result)

构造一个既是Future又是Runnable的对象。

用例：

public class MyFutureTask {

public static void main(String[] args) {

Callable primeCallable = new PrimeCallable(1000);

FutureTask primeTask = new FutureTask(primeCallable);

Thread t = new Thread(primeTask);

t.start();

try {

// 假设现在做其他事情

Thread.sleep(5000);

// 回来看看质数找好了吗

if (primeTask.isDone()) {

int[] primes = primeTask.get();

for (int prime : primes) {

System.out.print(prime + " ");

}

System.out.println();

}

} catch (InterruptedException e) {

e.printStackTrace();

} catch (ExecutionException e) {

e.printStackTrace();

}

}

}

class PrimeCallable implements Callable {

private int max;

public PrimeCallable(int max) {

this.max = max;

}

public int[] call() throws Exception {

int[] prime = new int[max + 1];

List list = new ArrayList();

for (int i = 2; i <= max; i++)

prime[i] = 1;

for (int i = 2; i * i <= max; i++) { // 这里可以改进

if (prime[i] == 1) {

for (int j = 2 * i; j <= max; j++) {

if (j % i == 0)

prime[j] = 0;

}

}

}

for (int i = 2; i < max; i++) {

if (prime[i] == 1) {

list.add(i);

}

}

int[] p = new int[list.size()];

for (int i = 0; i < p.length; i++) {

p[i] = list.get(i).intValue();

}

return p;

}

}