zoukankan      html  css  js  c++  java
  • Java FutureTask Example Program(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.

    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.

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

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

    
    package com.journaldev.threads;
    

    import java.util.concurrent.Callable;

    public class MyCallable implements Callable<String> {

    <span class="hljs-keyword">private</span> <span class="hljs-keyword">long</span> waitTime;
    
    <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-title">MyCallable</span><span class="hljs-params">(<span class="hljs-keyword">int</span> timeInMillis)</span></span>{
    	<span class="hljs-keyword">this</span>.waitTime=timeInMillis;
    }
    <span class="hljs-meta">@Override</span>
    <span class="hljs-function"><span class="hljs-keyword">public</span> String <span class="hljs-title">call</span><span class="hljs-params">()</span> <span class="hljs-keyword">throws</span> Exception </span>{
    	Thread.sleep(waitTime);
        <span class="hljs-comment">//return the thread name executing this callable task</span>
        <span class="hljs-keyword">return</span> Thread.currentThread().getName();
    }
    

    }

    Here is an example of FutureTask method and it’s showing commonly used methods of 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.

    Output of above program will be:

    Copy
    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.

  • 相关阅读:
    SQL 获取本年第几周
    SQL Server 数据类型
    (转)经典SQL查询语句大全
    mssql查询某个值存在某个表里的哪个字段的值里面
    SQL Server 数据库还原
    SQL Server 数据库备份
    【转】T-SQL 教程
    【原】C# decimal字符串转成整数
    Django基础篇(二)与mysql配合使用
    Django基础篇(一)
  • 原文地址:https://www.cnblogs.com/jpfss/p/9373312.html
Copyright © 2011-2022 走看看