Java并发35:Callable+Future系列--Future接口学习笔记

[超级链接:Java并发学习系列-绪论]


本章主要学习Future接口。

1.Future接口概述

Future接口代表着异步计算的结果。

Future接口提供了一些方法:查看计算是否完成、等待计算完成和获取计算结果。

只有在计算完成时,才能通过get()方法获取计算结果,必要时程序会阻塞直到计算完成。

取消计算是通过方法cancel()执行的。

此外,还提供了一些其他的方法用于确认任务是否正常(isDone())或者是否取消(isCancelled())。

一旦一个计算已经完成,则这个计算不能再被取消。

如果你因为可取消性而想使用Future接口,但是又不能提供一个可用的计算结果,那么你可以将其声明为Future<?>类型,并且以null值作为返回值。

示例用法

interface ArchiveSearcher {
    String search(String target);
}
class App {
    ExecutorService executor = ...
    ArchiveSearcher searcher = ...

    void showSearch(final String target)
            throws InterruptedException {
        Future<String> future
                = executor.submit(new Callable<String>() {
            public String call() {
                return searcher.search(target);
            }
        });
        displayOtherThings(); // do other things while searching
        try {
            displayText(future.get()); // use future
        } catch (ExecutionException ex) {
            cleanup();
            return;
        }
    }
}

谨记一致性影响:

一个线程池中异步计算的结果 happens-before 另一个线程中Future.get()方法之后的操作。

也就是说: 一个线程池中异步计算的结果 对 另一个线程中 Future.get()方法 之后的操作 可见。

2.Future的方法说明

Future的方法如下:

1.isDone():任务是否完成

2.isCancelled():任务是否取消了

3.cancel(mayInterruptIfRunning):

取消任务:

  • mayInterruptIfRunning = true:如果任务在运行,则即使中断任务,也要取消任务。
  • mayInterruptIfRunning = false:如果任务在运行,则等待任务运行完毕,再取消任务。

4.get():

阻塞的的获取计算结果,直到发生以下三种情况之一:

  • 获取了计算结果,返回结果。
  • 当前线程被中断被中断,抛出InterruptedException异常
  • 计算出错,则抛出ExecutionException异常

5.get(timeout,TimeUnit):

限定时间内,阻塞的的获取计算结果,直到发生以下四种情况之一:

  • 获取了计算结果,则返回结果。
  • 当前线程被中断被中断,则抛出InterruptedException异常
  • 计算出错,则抛出ExecutionException异常
  • 等待时间超时,则抛出TimeoutException异常

3.实例练习

练习目的:熟悉Future各方法的使用。

练习描述:

  • isDone()和isCancelled()的使用
  • cancel(true)的使用
  • get(timeout,TimeUnit)的使用
  • get()的使用

实例代码:

//定义一个线程池
ExecutorService executorService = Executors.newCachedThreadPool();
//定义一个Callable对象
Callable callable = new Callable() {
    @Override
    public Object call() throws Exception {
        //模拟开始计算
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            //e.printStackTrace();
            System.out.println("正在计算,被取消了");
        }
        //计算结束,返回结果
        return 100;
    }
};
//提交一个Callable任务,返回一个Future对象
Future<Integer> future = executorService.submit(callable);

try {
    Thread.sleep(1000);
} catch (InterruptedException e) {
    e.printStackTrace();
}
//isDone():任务是否完成
System.out.println("1000ms的时候计算是否完成:" + future.isDone());
//isCancelled():任务是否取消了
System.out.println("1000ms的时候计算是否取消:" + future.isCancelled());

System.out.println();
//cancel取消-true表示即使在运行也取消,false表示如果没运行可以取消
future.cancel(true);
try {
    Thread.sleep(1000);
} catch (InterruptedException e) {
    e.printStackTrace();
}
//isDone():任务是否完成
System.out.println("cancel之后计算是否完成:" + future.isDone());
//isCancelled():任务是否取消了
System.out.println("cancel之后计算是否取消:" + future.isCancelled());

System.out.println();
try {
    Thread.sleep(1000);
} catch (InterruptedException e) {
    e.printStackTrace();
}
//再次提交一个Callable任务,返回一个Future对象
future = executorService.submit(callable);

//在2秒时限内尝试去获取
//获取到则返回结果
//获取不到则返回
try {
    System.out.println("在2秒时限内尝试去获取:" + future.get(2, TimeUnit.SECONDS));
} catch (TimeoutException e) {
    //e.printStackTrace();
    System.out.println("timeout超时,抛出TimeoutException异常");
} catch (InterruptedException e) {
    //e.printStackTrace();
    System.out.println("线程interrupt,抛出InterruptedException异常");
} catch (ExecutionException e) {
    //e.printStackTrace();
    System.out.println("执行出错,抛出ExecutionException异常");
}
//isDone():任务是否完成
System.out.println("get(timeout,TimeUnit)超时之后,计算是否完成:" + future.isDone());
//isCancelled():任务是否取消了
System.out.println("get(timeout,TimeUnit)超时之后,cancel之后计算是否取消:" + future.isCancelled());

System.out.println();
//阻塞的等待计算结果,直到获取计算结果
try {
    System.out.println("阻塞的等待计算结果,直到获取计算结果:" + future.get());
} catch (InterruptedException e) {
    //e.printStackTrace();
    System.out.println("线程interrupt,抛出InterruptedException异常");
} catch (ExecutionException e) {
    //e.printStackTrace();
    System.out.println("执行出错,抛出ExecutionException异常");
}
//isDone():任务是否完成
System.out.println("get()之后,计算是否完成:" + future.isDone());
//isCancelled():任务是否取消了
System.out.println("get()之后,cancel之后计算是否取消:" + future.isCancelled());

//取消线程池
executorService.shutdown();

运行结果:

1000ms的时候计算是否完成:false
1000ms的时候计算是否取消:false

正在计算,被取消了
cancel之后计算是否完成:true
cancel之后计算是否取消:true

timeout超时,抛出TimeoutException异常
get(timeout,TimeUnit)超时之后,计算是否完成:false
get(timeout,TimeUnit)超时之后,cancel之后计算是否取消:false

阻塞的等待计算结果,直到获取计算结果:100
get()之后,计算是否完成:true
get()之后,cancel之后计算是否取消:false
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值