Callable与 Future

Callable与 Future 两功能是Java在后续版本中为了适应多并法才加入的，Callable是类似于Runnable的接口，实现Callable接口的类和实现Runnable的类都是可被其他线程执行的任务。

Callable的接口定义如下；

public interface Callable<V> { 

      V   call()   throws Exception; 

} 

Callable和Runnable的区别如下：

I    Callable定义的方法是call，而Runnable定义的方法是run。

II   Callable的call方法可以有返回值，而Runnable的run方法不能有返回值。

III  Callable的call方法可抛出异常，而Runnable的run方法不能抛出异常。  

Future 介绍

Future表示异步计算的结果，它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。Future的cancel方法可以取消任务的执行，它有一布尔参数，参数为 true 表示立即中断任务的执行，参数为 false 表示允许正在运行的任务运行完成。Future的 get 方法等待计算完成，获取计算结果

 

例子：

 

 

import java.io.*;
import java.util.*;
import java.util.concurrent.*;


public class FutureTest
{
   public static void main(String[] args) 
   {
      Scanner in = new Scanner(System.in);
      System.out.print("Enter base directory (e.g. /usr/local/jdk5.0/src): ");
      String directory = in.nextLine();
      System.out.print("Enter keyword (e.g. volatile): ");
      String keyword = in.nextLine();     
    
      MatchCounter counter = new MatchCounter(new File(directory), keyword);           
      FutureTask<Integer> task = new FutureTask<Integer>(counter);
      Thread t = new Thread(task);
      t.start();         
      try
      {
         System.out.println(task.get() + " matching files.");
      }
      catch (ExecutionException e)
      {
         e.printStackTrace();
      }
      catch (InterruptedException e) {}
   }
}


/**
   This task counts the files in a directory and its subdirectories that contain a given keyword.
*/
class MatchCounter implements Callable<Integer>
{
   /**
      Constructs a MatchCounter.
      @param directory the directory in which to start the search
      @param keyword the keyword to look for
   */
   public MatchCounter(File directory, String keyword)
   {
      this.directory = directory;      
      this.keyword = keyword;
   }


   public Integer call()
   {
      count = 0;
      try
      {
         File[] files = directory.listFiles();
         ArrayList<Future<Integer>> results = new ArrayList<Future<Integer>>();


         for (File file : files)      
            if (file.isDirectory()) 
            {               
               MatchCounter counter = new MatchCounter(file, keyword);           
               FutureTask<Integer> task = new FutureTask<Integer>(counter);
               results.add(task);
               Thread t = new Thread(task);
               t.start();         
            }
            else 
            {
               if (search(file)) count++;
            }
         
         for (Future<Integer> result : results)
            try
            {
               count += result.get();
            }
            catch (ExecutionException e)
            {
               e.printStackTrace();
            }
      }
      catch (InterruptedException e) {}
      return count;
   }


   /**
      Searches a file for a given keyword.
      @param file the file to search
      @return true if the keyword is contained in the file
   */
   public boolean search(File file)
   {     
      try
      {
         Scanner in = new Scanner(new FileInputStream(file));
         boolean found = false;
         while (!found && in.hasNextLine())
         {
            String line = in.nextLine();
            if (line.contains(keyword)) found = true;
         }
         in.close();
         return found;
      }
      catch (IOException e)
      {
         return false;
      }
   }


   private File directory;
   private String keyword;
   private int count;
}