Java線程之FutureTask與Future淺析

一、Future使用

        FutureTask是Future和Callable的結合體。傳統的代碼是這樣寫的

        Future f = executor.submit(new Callable());

        然后通過Future來取得計算結果。但是，若開啟了多個任務，我們無從知曉哪個任務最先結束。因此，若要實現“當某任務結束時，立刻做一些事情，例如記錄日志”這一功能，就需要寫一些額外的代碼。例如一般的Future使用。

多任務：

package zmx.multithread.test.reentrantlock;
 
 
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;
 
public class T1 {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
            
         ExecutorService executor2= Executors.newFixedThreadPool(5);          
         class Task implements Callable<String>{
            @Override
            public String call() throws Exception {
                
                Random rand = new Random();  
                TimeUnit.SECONDS.sleep(rand.nextInt(10));  
                return  Thread.currentThread().getName();
            }             
         }
         
         List<Future<String>> results = new ArrayList<Future<String>>();
         for(int i=0;i<5;i++){
             Future<String> f =  executor2.submit(new Task());
             results.add(f);
         }
 
         boolean flag =true; 
         while(flag) {
            
            for(Iterator<Future<String>> iter  = results.iterator();iter.hasNext();){
                Future<String> f =iter.next();
                if(f.isDone()){
                    System.out.println(f.get());
                    iter.remove();
                    
                }
            }
            if(results.size()==0){
                flag =false;
            }
            
        }
        
        System.out.println("執行完畢");
         
        executor2.shutdownNow();
         
         
         
    }
 
}

執行結果：

pool-1-thread-4
pool-1-thread-2
pool-1-thread-1
pool-1-thread-5
pool-1-thread-3
執行完畢

 

二、FutureTask

      上述使用遍歷的方式解決多任務結果，但是不是最優的效果，FutureTask正是為此而存在，它有一個回調函數protected void done()，當任務結束時，該回調函數會被觸發。因此，只需重載該函數，即可實現在線程剛結束時就做一些事情。

代碼如下：

public class Test {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newCachedThreadPool();
        for(int i=0; i<5; i++) {
            Callable<String> c = new Task();
            MyFutureTask ft = new MyFutureTask(c);
            executor.submit(ft);
        }
        executor.shutdown();
    }
        
}
 
class MyFutureTask extends FutureTask<String> {
 
    public MyFutureTask(Callable<String> callable) {
        super(callable);
    }
 
    @Override
    protected void done() {
        try {
            System.out.println(get() + " 線程執行完畢！~");
        } catch (InterruptedException | ExecutionException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    
    
}
 
class Task implements Callable<String> {
 
    @Override
    public String call() throws Exception {
        Random rand = new Random();
        TimeUnit.SECONDS.sleep(rand.nextInt(12));
        return Thread.currentThread().getName();
    }
}

結果如下：

pool-1-thread-4 線程執行完畢！
pool-1-thread-3 線程執行完畢！
pool-1-thread-5 線程執行完畢！
pool-1-thread-2 線程執行完畢！
pool-1-thread-1 線程執行完畢！