Java并发编程高级篇(三):执行器中执行任务并返回结果

原创
2017/03/02 09:33
阅读数 563

执行器框架的优质之一是可以并发地执行任务,并将任务执行结果返回。要想实现这个功能,需要JDK中的两个接口。

  • Callable:这个接口带有一个call()方法,你可以在这个方法里面实现任务执行逻辑,同时这个接口带有一个泛型参数,你可以通过这个泛型参数来指定返回结果的类型。
  • Future:这个接口生命了一些方法来获取由Callable对象产生的结果,并管理他们的状态。

创建一个类FactorialCalculator实现Callable接口,用于计算阶乘。泛型参数使用Integer来规定返回值为整型。

import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

/**
 * 创建一个名为FactorialCalculator类并实现Callable<Integer>接口
 *
 * 用来计算number的阶乘
 *
 * Created by hadoop on 2016/11/2.
 */
public class FactorialCalculator implements Callable<Integer> {
    private Integer number;

    public FactorialCalculator(Integer number) {
        this.number = number;
    }

    @Override
    public Integer call() throws Exception {
        int result = 1;

        if (number > 2) {
            for (int i = 2; i <= number; i++) {
                result *= i;
            }
        }

        TimeUnit.MILLISECONDS.sleep(200);

        return result;
    }
}

然后实现Main方法,循环10次,每次产生一个随机整数,然后调用FactorialCalculator来求这个整数的阶乘。注意这里使用submit()方法来提交callable任务,因为这个方法会返回一个Future对象,而不是前面两节那样使用的是execute方法来执行Runnable。

使用Futuee对象不但可以用来获取线程任务的返回值,还可以用于获取线程执行状态。

  • isDone():用于检查任务是否执行完成。
  • get():用于获取Callable的call()方法执行的返回结果,get()方法将一直等待call()方法执行完成。如果等待过程中线程中断了,那么将抛出InterrupedException异常,如果call()方法执行异常,那么get()方法将接着抛出ExecutionException。
  • get(long timeout, TimeUnit unit):等待一段时间,如果任务没有执行完毕,那么返回null。
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.*;

/**
 * 在执行器中执行任务并返回结果
 *
 * 执行器框架的优势之一在于可以并行执行任务,并且返回结果。Java并发API通过以下两个接口来s实现这个功能。
 * 1. Callable接口:这个借口生命了call()方法,你可以在这个方法中实现具体的处理逻辑。
 *    Callable接口带有泛型参数,这意味着call()方法可以返回该数据类型的对象。
 * 2. Future接口:这个接口用来接收Callable接口产生的结果,并管理他们的状态。
 *
 * 在本节我们学习了使用Callable接口来启动并发任务并返回结果。
 * 我么编写了FactorialCalculator类,它实现了带有泛型参数Integer的Callable接口。
 * 因此这个Integer类型将作为在调用call()方法的返回值类型。
 *
 * 另一个关键点在于Main类,在这个类中我们使用了submit()方法,发送一个Callable对象到执行器中。
 * 这个submit()方法接收Callable对象作为参数,然后返回Future对象。
 * Future对象可以用于以下两个目的。
 * 1. 控制任务的状态:可以取消或者检查任务是否完成。在这里我们使用了isDone方法来判断任务是否完成。
 * 2. 通过get()方法,接收call()方法返回的结果。这个方法一直等到call()方法执行完成并返回结果。
 *    如果get()方法在等待结果时线程中断了,将抛出一个InterruptedException。
 *    如果call()方法抛出异常,那么get方法抛出ExecutionException。
 *
 * Future对象还听了另一个future.get(1000, TimeUnit.NANOSECONDS)方法来接受返回值。
 * 如果等待(1000, TimeUnit.NANOSECONDS)时间,call()方法还没有执行结束,那么将直接返回null值。
 *
 * Created by hadoop on 2016/11/2.
 */
public class Main {
    public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {
        ThreadPoolExecutor executor = (ThreadPoolExecutor)Executors.newFixedThreadPool(2);

        List<Future<Integer>> futures = new ArrayList<Future<Integer>>();

        Random random = new Random();

        for (int i = 0; i < 10; i++) {
            Integer number = random.nextInt(10);

            FactorialCalculator calculator = new FactorialCalculator(number);

            Future<Integer> future = executor.submit(calculator);

            futures.add(future);
        }

        do {
            //System.out.printf("Main: Number of the completed Tasks: %d\n", executor.getCompletedTaskCount());

            for (int i = 0; i < futures.size(); i++) {
                Future<Integer> future = futures.get(i);
                //System.out.printf("Main: Tasks %d: %s\n", i, future.isDone());
            }

            try {
                TimeUnit.MILLISECONDS.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        } while (executor.getCompletedTaskCount() < futures.size());

        for (int i = 0; i < futures.size(); i++) {
            Future<Integer> future = futures.get(i);
            System.out.printf("Main: Tasks %d: %d\n", i, future.get());
            //System.out.printf("Main: Tasks %d: %d\n", i, future.get(1000, TimeUnit.NANOSECONDS));
        }

        executor.shutdown();
    }
}
展开阅读全文
加载中

作者的其它热门文章

打赏
0
0 收藏
分享
打赏
0 评论
0 收藏
0
分享
返回顶部
顶部