Future callable 線程池 獲取目錄下關鍵字

異步計算

package com.yzq.threadex;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

public class FutureTest {
  public static void main(String[] args) {
    try (Scanner in = new Scanner(System.in)) {
      System.out.println("Enter base directory(e.g /usr/local/jdk/src): ");
      String directory = in.nextLine();
      System.out.println("Enter keyword(e.g. volatile) : ");
      String keyword = in.nextLine();

      MatchCounter counter = new MatchCounter(new File(directory), keyword);
      FutureTask<Integer> task = new FutureTask<>(counter);
      Thread t = new Thread(task);
      t.start();
      try {
        System.out.println(task.get() + " matching files.");
      } catch (ExecutionException e) {
        e.printStackTrace();
      } catch (InterruptedException e) {
      }
    }
  }
}

class MatchCounter implements Callable<Integer> {
  private File directory;
  private String keyword;

  public MatchCounter(File directory, String keyword) {
    this.directory = directory;
    this.keyword = keyword;
  }

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

      for (File file : files) {
        if (file.isDirectory()) {
          MatchCounter counter = new MatchCounter(file, keyword);
          FutureTask<Integer> task = new FutureTask<>(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;
  }

  public boolean search(File file) {
    try {
      try (Scanner in = new Scanner(file, "UTF-8")) {
        boolean found = false;
        while (!found && in.hasNextLine()) {
          String line = in.nextLine();
          if (line.contains(keyword)) found = true;
        }
        return found;
      }
    } catch (IOException e) {
      return false;
    }
  }
}

線程池

package com.yzq.threadex;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.concurrent.*;

public class ThreadPollTest {
  public static void main(String[] args) throws Exception {
    try (Scanner in = new Scanner(System.in)) {
      System.out.println("Enter base directory(e.g /usr/local/jdk/src): ");
      String directory = in.nextLine();
      System.out.println("Enter keyword(e.g. volatile) : ");
      String keyword = in.nextLine();

      ExecutorService pool = Executors.newCachedThreadPool();

      MatchCounter counter = new MatchCounter(new File(directory), keyword, pool);
      Future<Integer> result = pool.submit(counter);

      try {
        System.out.println(result.get() + " matching files.");
      } catch (ExecutionException e) {
        e.printStackTrace();
      } catch (InterruptedException e) {
      }

      pool.shutdown();

      int largestPoolSize = ((ThreadPoolExecutor) pool).getLargestPoolSize();
      System.out.println("largest pool size= " + largestPoolSize);
    }
  }
}

class MatchCounter implements Callable<Integer> {
  private File directory;
  private String keyword;
  private ExecutorService pool;
  private int count;

  public MatchCounter(File directory, String keyword, ExecutorService pool) {
    this.directory = directory;
    this.keyword = keyword;
    this.pool = pool;
  }

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

      for (File file : files)
        if (file.isDirectory()) {
          MatchCounter counter = new MatchCounter(file, keyword, pool);
          Future<Integer> result = pool.submit(counter);
          results.add(result);
        } else if (search(file)) count++;

      for (Future<Integer> reslut : results) {
        try {
          count += reslut.get();
        } catch (ExecutionException e) {
          e.printStackTrace();
        }
      }
    } catch (InterruptedException e) {
    }
    return count;
  }

  public boolean search(File file) {
    try {
      try (Scanner in = new Scanner(file, "UTF-8")) {
        boolean found = false;
        while (!found && in.hasNextLine()) {
          String line = in.nextLine();
          if (line.contains(keyword)) found = true;
        }
        return found;
      }
    } catch (IOException e) {
      return false;
    }
  }
}