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.

  • 相关阅读:
    2020春软件工程助教工作总结【第十四周】
    【西北师大-20软工】第三次团队作业成绩汇总
    2020春软件工程助教工作总结【第十二周】
    2020春软件工程助教工作总结【第十周】
    将作业提交到班级博客的一些注意事项
    操作系统第6次实验报告:使用信号量解决进程互斥访问
    操作系统第5次实验报告:内存管理
    操作系统第4次实验报告:文件系统
    操作系统第3次实验报告:管道
    操作系统第2次实验报告:创建进程
  • 原文地址:https://www.cnblogs.com/jpfss/p/9373312.html
Copyright © 2011-2022 走看看