哪一个更快：从控制台读取或写入文件和阅读？

Question

我有一个目录中的非常大（〜300 MB）文件的列表，需要使用awk脚本多次过滤，每次使用不同的搜索参数。 我已经编写了一个程序，它使用fixedThreadPool执行程序生成多个线程，并且每个线程内的任务实现都会创建一个新的Runtime（）对象，并通过一个使用bash shell执行的新Process来执行awk脚本脚本

下面是一个示例代码：

类MultiThreadingImpl：

public class MultiThreadingImpl { 
    static List<File> filesList = new ArrayList<File>(); 

    public static void main(String[] args) { 
     int numThreads = Runtime.getRuntime().availableProcessors(); 
     ExecutorService executor = Executors.newFixedThreadPool(numThreads);//creating a pool of 5 threads 

     File logsDir = new File("TestFilesDir"); 
     getLogFiles(logsDir); 
     String[] searchKeys = {"123456","PAT1"}; 

     for (int i = 0; i < filesList.size() ; i++) { 
      Runnable worker = new WorkerThread(filesList.get(i),searchKeys[i]); 
      executor.execute(worker);//calling execute method of ExecutorService 
      } 
     executor.shutdown(); 

     while (!executor.isTerminated()) { } 

     System.out.println("Finished all threads"); 

    } 

    private static void getLogFiles(File logsDir) { 
     assert(logsDir.isDirectory()); 

     for(File f : logsDir.listFiles(
       new FilenameFilter(){ 
        public boolean accept(File dir, String name) { 

         return !name.endsWith("_result.txt"); 
        } 

       } 
       )){ 
      filesList.add(f); 
     } 

    } 
} 

类的WorkerThread：

class WorkerThread implements Runnable { 
    private String outputFile; 
    private String searchKey; 
    private File logFile; 

    public WorkerThread(File logFile,String searchKey){ 
     this.logFile = logFile; 
     this.searchKey = searchKey; 
     this.outputFile = String.format(logFile.getName().replace(".txt", "") + "_result.txt"); 
    } 

    public void run() { 
     int res = 0; 
     Runtime runtime = Runtime.getRuntime(); 
     String awkRegex = new StringBuilder("'/([0-9]{1}|[0-9]{2})[[:space:]][[:alpha:]]+[[:space:]][0-9]{4}/{n=0}") 
          .append("/"+searchKey+"/").append("{n=1} n' ").toString(); 
     String awkCommand = new StringBuilder("/usr/bin/awk ").append(awkRegex) 
       .append(logFile.getAbsolutePath()).append(" &> ").append("/TestFilesDir").append(outputFile).toString(); 
     System.out.println(Thread.currentThread().getName() + ":: Command : " + awkCommand); 
     String[] cmdList = { "/bin/bash", "-c", awkCommand}; 

     try { 
      final Process process = runtime.exec(cmdList); 

      res = process.waitFor(); 

      BufferedReader stdInput = new BufferedReader(new InputStreamReader(process.getInputStream())); 
      BufferedReader stdError = new BufferedReader(new InputStreamReader(process.getErrorStream())); 


      while (stdInput.readLine() != null) { 
       //Emptying stream 
      } 

      StringBuffer strerror = new StringBuffer(); 
      String serror = null; 
      while ((serror = stdError.readLine()) != null) { 
       strerror.append(serror + "\n"); 
      } 

      System.out.println(Thread.currentThread().getName() + ":: Process Exit value: " + res); 


     } catch (IOException e) { 
      e.printStackTrace(); 
     } catch (InterruptedException e) { 
      e.printStackTrace(); 
     } 

    } 

} 

这里我可以选择写入每个输入文件的唯一输出文件，然后使用cat合并它们，最后读取合并的文件。

而且我也可以选择将每个Process的输出流的输出读入一个字符串并合并所有字符串。

哪种机制更快？

还建议是否有办法让整个事情更快？

Answer 1

• 不使用Runtime（）和'awk'脚本。而是将'awk'脚本翻译成Java。即使Java版本的运行速度比'awk'慢一点，混合'awk'和Java也会使程序复杂化。

• 另外，不要为每个要处理的文件创建一个线程（每次创建新线程时都会有开销）。相反，只能使用固定数量的线程，并通过一些逻辑在这些线程之间平均分配文件。每个线程将按顺序处理几个文件。 （它需要更多的速度，然后把文件在某些​​共享文件系统 - 例如S3 - 然后使用多台电脑处理文件

Answer 2

从视图的操作点：这不应该有事实上，很多现代操作系统都有系统调用，但实际上不应该有任何开销，但是，你在Java中做了一些可能会有一些开销的事情（整个缓冲读取器业务：为什么？）

还建议是否有办法让整件事情更快？

为什么从Java中调用一个叫做awk的shell来解析表达式来过滤事物？

只需在Java中使用字符串/正则表达式引擎即可。 Java本身确实有一些速度限制，但我相信它们可能并不严重;在BufferedStreamReader(InputStreamReader)构造中有一些开销，所以如果你真的把性能的最后一点挤出来，你肯定会继续，并在本地代码中实现所有这些;再次，我不相信你会比使用Java带来的工具赢得更多。

算法上，你在做什么是坏的：通过每个文件一次，一次做所有的过滤，不要多次遍历每个文件。产生不必要的新进程也会产生额外的开销。

多线程在这里没有帮助。你绝对不是CPU绑定的，但IO绑定和多线程不能增加存储带宽 - 相反，它通常甚至会破坏线性访问并使事情变得更慢。

这一切都觉得它需要10行shell脚本而不是复杂的多线程Java应用程序，并且启动和执行的速度会更快。