从Java开始忽略/捕获子进程输出的最简单方法

Question

java中的子进程非常昂贵。每个进程通常由多个线程支持。

• 一个线程来承载进程（通过Linux上的JDK 1.6）
• 一个线程来读取以读取/打印/忽略输入流
• 另一个线程来读取/打印/忽略错误流
• 更多线程来执行超时和监视并终止子进程由您的应用程序的
• 业务逻辑线程，保持直到子流程返回。

如果你有一个线程池子进程来执行任务，线程的数量就会失控。因此，峰值时可能有超过两倍的并发线程。

在很多情况下，我们fork一个进程只是因为没有人能够编写JNI来调用JDK中缺少的本机函数（例如chmod，ln，ls），触发shell脚本等。

有些线程可以被保存，但有些线程应该运行以防止最坏的情况（输入流上的缓冲区溢出）。

如何将Java中创建子进程的开销降至最低？ 我正在考虑 NIO 流处理、组合和共享线程、降低后台线程优先级、重用进程。但我不知道它们是否可能。

Answer 1

JDK7将解决这个问题并提供新的API redirectOutput/redirectError 重定向 stdout/stderr。

然而坏消息是他们忘记提供“Redirect.toNull”，这意味着你会想要做类似“if(*nix)/dev/null elsif(win)nil”的事情，

令人难以置信的是 NIO/2 api for Process 仍然丢失的;但我认为redirectOutput+NIO2的AsynchronizeChannel会有帮助。

Answer 2

我创建了一个开源库，允许 java 和子进程之间的非阻塞 I/O。该库提供了事件驱动的回调模型。它依赖于 JNA 库来使用特定于平台的本机 API，例如 Linux 上的 epoll、MacOS X 上的 kqueue/kevent 或 Windows 上的 IO Completion Ports。

该项目名为 NuProcess，可以在这里找到：

https://github.com/brettwooldridge/NuProcess

Answer 3

要回答您的主题（我不明白描述），我假设您的意思是 shell 子进程输出，请检查这些 SO 问题：

Java 的平台独立 /dev/null 输出接收器

Java 中是否存在 Null OutputStream？

或者您可以关闭 Unix 下正在执行的命令的 stdout 和 stderr：

command > /dev/null 2>&1

Answer 4

您不需要任何额外的线程来在 java 中运行子进程，尽管处理超时确实使事情变得有点复杂：

import java.io.IOException;
import java.io.InputStream;

public class ProcessTest {

  public static void main(String[] args) throws IOException {
    long timeout = 10;

    ProcessBuilder builder = new ProcessBuilder("cmd", "a.cmd");
    builder.redirectErrorStream(true); // so we can ignore the error stream
    Process process = builder.start();
    InputStream out = process.getInputStream();

    long endTime = System.currentTimeMillis() + timeout;

    while (isAlive(process) && System.currentTimeMillis() < endTime) {
      int n = out.available();
      if (n > 0) {
        // out.skip(n);
        byte[] b = new byte[n];
        out.read(b, 0, n);
        System.out.println(new String(b, 0, n));
      }

      try {
        Thread.sleep(10);
      }
      catch (InterruptedException e) {
      }
    }

    if (isAlive(process)) {
      process.destroy();
      System.out.println("timeout");
    }
    else {
      System.out.println(process.exitValue());
    }
  }

  public static boolean isAlive(Process p) {
    try {
      p.exitValue();
      return false;
    }
    catch (IllegalThreadStateException e) {
      return true;
    }
  }
}

您也可以使用反射，如 是否可以从具有超时的输入流中读取？ 获取 NIO Process.getInputStream() 的 >FileChannel，但是您必须担心不同的 JDK 版本以换取摆脱轮询。

Answer 5

nio 不起作用，因为当您创建进程时，您只能访问 OutputStream，而不能访问 Channel。

您可以让 1 个线程读取多个 InputStream。

例如，

import java.io.InputStream;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

class MultiSwallower implements Runnable {    
   private List<InputStream> streams = new CopyOnWriteArrayList<InputStream>();
   public void addStream(InputStream s) {
       streams.add(s);
   }

   public void removeStream(InputStream s) {
       streams.remove(s);
   }

    public void run() {
        byte[] buffer = new byte[1024];
        while(true) {

          boolean sleep = true;
          for(InputStream s : streams) {
              //available tells you how many bytes you can read without blocking
              while(s.available() > 0) {
                  //do what you want with the output here
                  s.read(buffer, 0, Math.min(s.available(), 1024));
                  sleep = false;
              }   
          }
          if(sleep) {
              //if nothing is available now
              //sleep 
              Thread.sleep(50);
          }
        }

    }
}

您可以将上述类与等待进程完成的另一个类配对，例如，

class ProcessWatcher implements Runnable {

    private MultiSwallower swallower = new MultiSwallower();

    private ConcurrentMap<Process, InputStream> proceses = new ConcurrentHashMap<Process, InputStream>();

    public ProcessWatcher() {

    } 

    public void startThreads() { 
        new Thread(this).start();
        new Thread(swallower).start();
    }


    public void addProcess(Process p) {
        swallower.add(p.getInputStream());
        proceses.put(p, p.getInputStream());

    }

    @Override
    public void run() {
        while(true) {

            for(Process p : proceses.keySet()) {
                try {
                    //will throw if the process has not completed
                    p.exitValue();
                    InputStream s = proceses.remove(p);
                    swallower.removeStream(s);
                } catch(IllegalThreadStateException e) { 
                    //process not completed, ignore
                }
            }
            //wait before checking again
            Thread.sleep(50);
        }
    }
}

如果您使用 ProcessBuilder.redirectErrorStream(true)，则不需要为每个错误流拥有 1 个线程，并且您不需要 1 个线程来读取进程输入流，如果您不向输入流写入任何内容，则可以简单地忽略该输入流。

Answer 6

既然您提到了 chmod、ln、ls 和 shell 脚本，听起来您正在尝试使用 Java 进行 shell 编程。如果是这样，您可能需要考虑使用更适合该任务的其他语言，例如 Python、Perl 或 Bash。虽然当然可以在 Java 中创建子进程，通过标准输入/输出/错误流等与它们交互，但我认为您会发现脚本语言使此类代码比 Java 更简洁且更易于维护。

Answer 7

您是否考虑过使用用另一种语言（可能是 shell 脚本？）编写的单个长时间运行的帮助程序进程，该进程将通过 stdin 使用来自 java 的命令并执行文件操作作为响应？