如何使用Callable和FutureTask

介绍

从Java 1.5开始，在java.util.concurrent下有了新的对象集。 该程序包具有许多不同的类，包括线程队列。 当我用Java 1.2编程时，我本可以使用那些！ 当我开始看这些新玩具时，我变得犹豫不决。 这是什么可调用的东西，未来是什么？ 事实证明，未来和可赎回没有错。 实际上，它们是我在Java生涯中一直期望的。

可调用和可运行之间的区别

可调用是Runnable希望成为的。 Callable的唯一方法是“ T call（）”。 使它如此整洁的原因是它返回了一些东西。 这是必须为任务的答案创建吸气剂的步骤。 虽然这很酷，但仍需要一种获取返回值的方法。

未来在这里

当Callable完成时，Future有一种获取价值的方法。 该函数是get（）或get（长超时，TimeUnit单位）。 这等效于调用thread.join（）;。 同时运行runnable.getValue（）。

例

我创建了一个名为CounterCallable的类。 它所做的只是从变量开始到变量结束加数字。

可赎回

package org.mathison.futurecallable;

import java.util.concurrent.Callable;

/**
 *
 * @author Daryl
 */
public class CounterCallable implements Callable {

    private long start;
    private long end;

    public CounterCallable(long start, long end) {
        this.start = start;
        this.end = end;
    }

    @Override
    public SumTimeAnswer call() throws Exception {
        long sum = 0;
        long startTime = System.currentTimeMillis();
        for(long i = start; i <= end; i++){
            sum += i;
        }
        long endTime = System.currentTimeMillis();

        return new SumTimeAnswer(sum, endTime - startTime);
    }
}

SumTimeAnswer

SumTimeAnswer类实际上是一个简单的getter类，它保存执行操作所需的时间总和。

package org.mathison.futurecallable;

/**
 *
 * @author Daryl
 */
public class SumTimeAnswer {
    private long timeToFinish;
    private long sum;

    public SumTimeAnswer(long sum, long timeToFinish) {
        this.sum = sum;
        this.timeToFinish = timeToFinish;
    }

    public long getTimeToFinish() {
        return timeToFinish;
    }

    public long getSum() {
        return sum;
    }
}

应用程式

应用程序只是将所有内容汇集在一起​​的主要课程

package org.mathison.futurecallable;

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

/**
 * Hello world!
 *
 */
public class App 
{
    public static final long BEGIN = 0;
    public static final long END = 100000;
    public static void main( String[] args )
    {
        FutureTask task = new FutureTask(new CounterCallable(BEGIN, END));
        FutureTask firstHalf = new FutureTask(new CounterCallable(BEGIN, END/2));
        FutureTask secondHalf = new FutureTask(new CounterCallable(END/2 + 1, END));
        
        ExecutorService pool = Executors.newSingleThreadExecutor();
        pool.submit(task);
        pool.submit(firstHalf);
        pool.submit(secondHalf);
        
        try {
            SumTimeAnswer taskAnswer = task.get();
            System.out.println("just one thread Time: " + taskAnswer.getTimeToFinish()
                + " Total: " + taskAnswer.getSum());
            
            
            SumTimeAnswer taskFirstAnswer = firstHalf.get();
            SumTimeAnswer taskSecondAnswer = secondHalf.get();
            long totalTime = taskFirstAnswer.getTimeToFinish() + taskSecondAnswer.getTimeToFinish();
            long totalSum = taskFirstAnswer.getSum() + taskSecondAnswer.getSum();
            System.out.println("Two thread time: " + totalTime + " Total: " + totalSum);
        } catch(CancellationException | InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        pool.shutdown();
    }
}

结论

在本文中，使用Callable和FutureTask类来演示如何使用java.util.concurrent包。

翻译自: https://www.javacodegeeks.com/2014/10/how-to-use-callable-and-futuretask.html