线程启动的运行进程不会破坏（Java）

Question

启动多个线程并让每个 exec() 然后destroy() 一个正在运行的 java 进程会导致某些进程没有被销毁并且在程序退出后仍在运行。这是一些重现该问题的代码。我注意到你启动的线程越多，存活的进程就越多。而且在destroy()之前睡眠越多，存活的进程就越少。 （我以 InfiniteLoop 为例。任何正在运行的进程都可以解决问题。）

编辑：已向 Oracle 报告错误，等待答复。随时分享有关该主题的任何知识/实验。

for(int i = 0; i < 100; i++)
{
  new Thread(new Runnable()
  {
    public void run()
    {
      try
      {
        Process p = Runtime.getRuntime().exec(new String[]{"java", "InfiniteLoop"});
        Thread.sleep(1);
        p.destroy();
      }catch(IOException | InterruptedException e){e.printStackTrace();}                    
    }
  }).start();
}

Answer 1

在p.destroy(); 之前使用p.waitFor();，

这将确保前一个过程的完成。我认为您 p.destroy 命令比 exec() 命令执行操作更快地被调用。因此它变得无用。

Answer 2

如果子进程向 stdout 或 stderr 写入任何内容（有意或无意），这可能会导致麻烦：

"因为一些原生平台只提供有限的缓冲区大小 标准输入输出流，未能及时写入输入 流或读取子进程的输出流可能会导致 子进程阻塞，甚至死锁。"

来源：http://www.javaworld.com/jw-12-2000/jw-1229-traps.html

如果你需要使用 Runtime.exec()，整篇文章是 IMO 值得一读的。

Answer 3

这仅仅是因为在线程执行销毁调用之前，您的主程序终止并且所有关联的线程使启动的进程继续运行。要验证这一点，只需在销毁之后添加一个 System.out 调用，您会发现它没有被执行。为了克服这个问题，在你的 main 方法的末尾添加一个 Thread.sleep 并且你不会有孤立的进程。以下不会让任何进程运行。

public class ProcessTest {

public static final void main (String[] args) throws Exception {

    for(int i = 0; i < 100; i++) {
        new Thread(new Runnable()
            {
                public void run() {
                    try {
                        Process p = Runtime.getRuntime().exec(new String[]{"java", "InfiniteLoop"});
                        Thread.sleep(1);
                        p.destroy();
                        System.out.println("Destroyed");
                    }catch(IOException e) {
                        System.err.println("exception: " + e.getMessage());
                    } catch(InterruptedException e){
                        System.err.println("exception: " + e.getMessage());
                    }
                }
            }).start();
    }


    Thread.sleep(1000);

}

}

Answer 4

您应该关闭进程的输入/输出/错误流。我们在过去看到了一些问题，即由于这些流没有关闭（即使它们没有被使用），分叉进程没有正确完成。

一个典型的解决方案：

p.destroy();
p.getInputStream().close();
p.getOutputStream().close();
p.getErrorStream().close();

Answer 5

我相信根据link，操作系统会产生一个不同的进程来响应这个调用。此进程的生命周期独立于您的 Java 程序和其中的线程，因此您希望它在程序退出后继续运行。我刚刚在我的机器上试了一下，它似乎按预期工作：

import java.io.*;

class Mp {
public static void main(String []args) {
    for(int i = 0; i < 100; i++) {
        new Thread(new Runnable() {
            public void run() {
                try {
                    System.out.println("1");
                    Process p = Runtime.getRuntime().exec
                        (new String[]{"notepad", ""});
                    System.out.println("2");
                    Thread.sleep(5);
                    System.out.println("3");
                    p.destroy();
                    System.out.println("4");
                }
                catch(IOException | InterruptedException e) {
                    e.printStackTrace();
                }                    
            }
        }).start();
    }
}
}

Answer 6

这不是答案；根据问题 cmets 中的讨论，我正在发布我自己尝试重现此问题的完整源代码。

我无法在 Ubuntu 12.04 上重现此问题； OpenJDK 6b_27（不过，见下文）。

ProcessTest.java：

import java.io.*;

public class ProcessTest {

    public static final void main (String[] args) throws Exception {

        for(int i = 0; i < 100; i++) {
            new Thread(new Runnable() 
                {
                    public void run() {
                        try {
                            Process p = Runtime.getRuntime().exec(new String[]{"java", "InfiniteLoop"});
                            Thread.sleep(1);
                            p.destroy();
                        }catch(IOException e) {
                            System.err.println("exception: " + e.getMessage());
                        } catch(InterruptedException e){
                            System.err.println("exception: " + e.getMessage());
                        }                    
                    }
                }).start();
        }

    }

}

无限循环.java

public class InfiniteLoop {
    public static final void main (String[] args) {
        while (true) ;
    }
}

我无法重现 JVM 终止后进程仍在运行的问题。但是，如果我在启动线程之后但在从主线程返回之前在主线程中添加一个长时间的延迟，我确实会看到大约十几个正在运行的 Java 进程仍然存在（尽管它们在主程序终止时终止）。

更新：

我只是让它在它终止后留下大约 5 个进程运行。它并不总是发生。诡异的。我也想了解更多。我有一种预感，它与过快地破坏进程或某种竞争条件有关；也许 java 分叉了一些东西或者做一些事情来创建一个新的进程，如果调用太快/在错误的时间，destroy() 不会处理。

我发现了一个旧错误（但它没有标记为已解决），指出如果一个进程产生子进程，它们可能不会被 destroy() 杀死。 bugs.sun.com/bugdatabase/view_bug.do?bug_id=4770092你用的是什么版本的JDK。

这里是另一个看起来类似问题的参考：Java tool/method to force-kill a child process 如果我只是给你的生活增添了困惑，我想道歉，我实际上并没有那么多使用 Process 并且不熟悉这些怪癖。希望其他人会介入并给出明确的答案。似乎它不能很好地处理子进程，我假设 java 分叉了一些东西。这就是我的全部。

Answer 7

在 Runtime.exec 启动 新线程 以启动进程与您告诉该进程自行销毁之间存在竞争条件。

我在linux机器上，所以我将使用UNIXProcess.class文件来说明。

Runtime.exec(...) 将创建一个新的 ProcessBuilder 并在 unix 机器上启动它创建一个新的 UNIXProcess 实例。在UNIXProcess 的构造函数中，有一段代码实际上在后台（分叉）线程中执行进程：

java.security.AccessController.doPrivileged(
            new java.security.PrivilegedAction() {
    public Object run() {
    Thread t = new Thread("process reaper") {
        public void run() {
                    try {
                        pid = forkAndExec(prog,
                      argBlock, argc,
                      envBlock, envc,
                      dir,
                      redirectErrorStream,
                      stdin_fd, stdout_fd, stderr_fd);
                    } catch (IOException e) {
                        gate.setException(e); /*remember to rethrow later*/
                        gate.exit();
                        return;
                    }
                    java.security.AccessController.doPrivileged(
                    new java.security.PrivilegedAction() {
                        public Object run() {
                        stdin_stream = new BufferedOutputStream(new
                                                FileOutputStream(stdin_fd));
                        stdout_stream = new BufferedInputStream(new
                                                FileInputStream(stdout_fd));
                        stderr_stream = new FileInputStream(stderr_fd);
                        return null;
                    }
                    });
                    gate.exit(); /* exit from constructor */
        int res = waitForProcessExit(pid);
        synchronized (UNIXProcess.this) {
            hasExited = true;
            exitcode = res;
            UNIXProcess.this.notifyAll();
        }
        }
    };
            t.setDaemon(true);
            t.start();
    return null;
    }
});

请注意，后台线程设置了字段pid，它是UNIX 进程ID。这将被destroy() 用来告诉操作系统要杀死哪个进程。

因为在调用destroy() 时无法确保该后台线程已经运行，所以我们可能会在进程运行之前尝试将其杀死，或者我们可能会在设置pid 字段之前尝试将其杀死； pid 未初始化，因此为 0。所以我认为过早调用 destroy 将相当于 kill -9 0

UNIXProcess destroy() 中甚至有一条评论暗示了这一点，但只考虑在进程完成后调用destroy，而不是在它开始之前：

// There is a risk that pid will be recycled, causing us to
// kill the wrong process!  So we only terminate processes
// that appear to still be running.  Even with this check,
// there is an unavoidable race condition here, but the window
// is very small, and OSes try hard to not recycle pids too
// soon, so this is quite safe.

pid 字段甚至没有被标记为 volatile，因此我们甚至可能始终看不到最新的值。

Answer 8

我遇到了一个非常相似的问题，destroy() 无法正常工作的问题即使使用单个线程也很明显。

Process process = processBuilder(ForeverRunningMain.class).start()
long endTime = System.currentTimeMillis() + TIMEOUT_MS; 
while (System.currentTimeMillis() < endTime) {
    sleep(50);
}
process.destroy();

如果TIMEOUT_MS 太低，进程并不总是被破坏。 在destroy() 之前添加一个额外的sleep() 修复了它（尽管我没有解释原因）：

Thread.sleep(300);
process.destroy();