Java FutureTask示例程序

Sometime back I wrote a post about Java Callable Future interfaces that we can use to get the concurrent processing benefits of threads as well as they are capable of returning value to the calling program.

有时我写了一篇有关Java Callable Future接口的文章，我们可以使用它来获得线程的并发处理优势以及它们能够将值返回给调用程序。

FutureTask is base concrete implementation of Future interface and provides asynchronous processing. It contains the methods to start and cancel a task and also methods that can return the state of the FutureTask as whether it’s completed or cancelled. We need a callable object to create a future task and then we can use Java Thread Pool Executor to process these asynchronously.

FutureTask是Future接口的基础具体实现，并提供异步处理。 它包含启动和取消任务的方法，以及可以返回FutureTask的状态为已完成还是已取消的方法。 我们需要一个可调用的对象来创建未来的任务，然后我们可以使用Java线程池执行器来异步处理这些任务。

Let’s see the example of FutureTask with a simple program.

让我们看一个带有简单程序的FutureTask示例。

Since FutureTask requires a callable object, we will create a simple Callable implementation.

由于FutureTask需要一个可调用对象，因此我们将创建一个简单的Callable实现。

package com.journaldev.threads;

import java.util.concurrent.Callable;

public class MyCallable implements Callable<String> {

	private long waitTime;
	
	public MyCallable(int timeInMillis){
		this.waitTime=timeInMillis;
	}
	@Override
	public String call() throws Exception {
		Thread.sleep(waitTime);
        //return the thread name executing this callable task
        return Thread.currentThread().getName();
	}

}

Here is an example of FutureTask method and it’s showing commonly used methods of FutureTask.

这是FutureTask方法的示例，它显示了FutureTask的常用方法。

package com.journaldev.threads;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class FutureTaskExample {

	public static void main(String[] args) {
		MyCallable callable1 = new MyCallable(1000);
		MyCallable callable2 = new MyCallable(2000);

		FutureTask<String> futureTask1 = new FutureTask<String>(callable1);
		FutureTask<String> futureTask2 = new FutureTask<String>(callable2);

		ExecutorService executor = Executors.newFixedThreadPool(2);
		executor.execute(futureTask1);
		executor.execute(futureTask2);
		
		while (true) {
			try {
				if(futureTask1.isDone() && futureTask2.isDone()){
					System.out.println("Done");
					//shut down executor service
					executor.shutdown();
					return;
				}
				
				if(!futureTask1.isDone()){
				//wait indefinitely for future task to complete
				System.out.println("FutureTask1 output="+futureTask1.get());
				}
				
				System.out.println("Waiting for FutureTask2 to complete");
				String s = futureTask2.get(200L, TimeUnit.MILLISECONDS);
				if(s !=null){
					System.out.println("FutureTask2 output="+s);
				}
			} catch (InterruptedException | ExecutionException e) {
				e.printStackTrace();
			}catch(TimeoutException e){
				//do nothing
			}
		}
		
	}

}

When we run above program, you will notice that it doesn’t print anything for sometime because get() method of FutureTask waits for the task to get completed and then returns the output object. There is an overloaded method also to wait for only specified amount of time and we are using it for futureTask2. Also notice the use of isDone() method to make sure program gets terminated once all the tasks are executed.

当我们在上面的程序上运行时，您会注意到它有时不打印任何内容，因为FutureTask的get()方法等待任务完成，然后返回输出对象。 还有一个重载方法也只能等待指定的时间，我们将它用于futureTask2。 还要注意，使用isDone()方法可确保在执行所有任务后终止程序。

Output of above program will be:

上面程序的输出将是：

FutureTask1 output=pool-1-thread-1
Waiting for FutureTask2 to complete
Waiting for FutureTask2 to complete
Waiting for FutureTask2 to complete
Waiting for FutureTask2 to complete
Waiting for FutureTask2 to complete
FutureTask2 output=pool-1-thread-2
Done

As such there is no benefit of FutureTask but it comes handy when we want to override some of Future interface methods and don’t want to implement every method of Future interface.

因此，FutureTask没有任何好处，但是当我们想要重写某些Future接口方法并且不想实现Future接口的每个方法时，它就派上用场了。

翻译自: https://www.journaldev.com/1650/java-futuretask-example-program