捕获进程 ID Java 的问题

Question

我最近问了一个question，它帮助我了解了 C 程序在 Java 方面的作用。我现在的目标是对两个新的子进程执行类似 C 的 fork，同时跟踪父进程 ID 和子进程 ID。但是，我不确定这是否可行。

在这里，我尝试启动进程 P 并运行两个子进程（我认为它们是 InputStreamReaders isr 和 wasr ）。我已经得到了进程 P 的 PID。但是，我卡住的地方是 InputStreamReader 并不是一个真正的进程，所以我无法获得进程 ID。

我会像在另一篇文章中提到的那样，这是一个家庭作业，它提供 C 代码指令但敦促 Java 代码响应。最终目标是能够打印“父进程 ID 的子进程 ID 已开始”和“子进程 ID 已终止”——这就是我跟踪每个人的 ID 很重要的原因。

我找到了另一个post，但我不知道如何适应它。

更新：在另一个 SO 用户的帮助下，我意识到我可能以错误的方式处理问题。这里，父进程是java进程，子进程是native进程。下面更新了代码。

原始代码

import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;


class processesorigin {
public static void main(String[] args) {
    try {
        Process p = Runtime.getRuntime().exec("/bin/ls");
        final InputStream is = p.getInputStream();
        final InputStream was = p.getInputStream();
        Thread t = new Thread(new Runnable() {
            public void run() {
                InputStreamReader isr = new InputStreamReader(is);
                InputStreamReader wasr = new InputStreamReader(was);
                int ch;
                try {
                    while ((ch = isr.read()) != -1) {
                        System.out.print((char) ch);
                    }
                    while ((ch = wasr.read()) != -1) {
                         System.out.print((char) ch);
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
        p.waitFor();
        t.join();
        int pid = 0;
        if(p.getClass().getName().equals("java.lang.UNIXProcess")) {
            try {
                Field f = p.getClass().getDeclaredField("pid");
                f.setAccessible(true);
                pid = f.getInt(p);
                }
            catch (Throwable e) {
                }
            }
        System.out.println("Process " + pid + " terminates.");
    } catch (Exception e) {
        e.printStackTrace();
    }
}
}

更新的代码 使用这些tips 和另一个 SO 用户，我发现了如何捕获 Java 进程 ID。然而，每个进程的开始信号仍然存在问题。不过，这可能是另一个问题。

import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import sun.management.VMManagement;
import java.lang.management.ManagementFactory;
import java.lang.management.RuntimeMXBean;


class processesorigin {
  public static void main(String[] args) {
    try {
      Process p = Runtime.getRuntime().exec("/bin/ls");
      Process q = Runtime.getRuntime().exec("/bin/ls");
      final InputStream is = p.getInputStream();
      final InputStream was = q.getInputStream();

      /*get PID of Java process*/
      final String runtimeName = ManagementFactory.getRuntimeMXBean().getName();
      final String jvmPid = runtimeName.split("@")[0];

      int pid = 0;
      int qid = 0;
      if(p.getClass().getName().equals("java.lang.UNIXProcess")) {
        /* get the PID of child processes : native ls command*/
        try {
          Field f = p.getClass().getDeclaredField("pid");
          Field g = q.getClass().getDeclaredField("pid");
          f.setAccessible(true);
          g.setAccessible(true);
          pid = f.getInt(p);
          qid = g.getInt(q);
        }
        catch (Throwable e) {
        }
      }

      final int pidCopy = pid;
      final int qidCopy = qid;
      Thread t = new Thread(new Runnable() {
        public void run() {
          InputStreamReader isr = new InputStreamReader(is);
          InputStreamReader wasr = new InputStreamReader(was);
          int ch;
          try {
            System.out.print("Child process " + pidCopy + " of Parent process " + jvmPid + " begun.");
            while ((ch = isr.read()) != -1) {
              System.out.print((char) ch);
            }
            System.out.print("Child process " + qidCopy + " of Parent process " + jvmPid + " begun.");
            while ((ch = wasr.read()) != -1) {
              System.out.print((char) ch);
            }                 
          } catch (IOException e) {
            e.printStackTrace();
          }
        }
      });
      t.start();
      p.waitFor();
      q.waitFor();
      t.join();
      System.out.println("Child process " + pidCopy + " terminated.");
      System.out.println("Child process " + qidCopy + " terminated.");
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

Answer 1

关于您的更新：获取本机子进程 PID 的方式也应该适用于 OSX。

由于您的任务是从 Java 启动两个子进程（对吗？），您可以使用 Runtime.getRuntime().exec() 启动两个本机进程，读取并打印每个进程的标准输出，并获取并打印每个进程的 PID。

您可以选择在主线程中运行两个进程或在单独的线程中启动每个进程，基本上就像在您的示例中所做的那样。

Answer 2

我不确定我是否完全理解您想要实现的目标，但也许这对您有所帮助。它是一个很小的 ​​C 程序，是一种包装器，您可以使用它来启动本机进程并从 Java 代码中获取其 PID：

#include <unistd.h>
#include <stdio.h>

/*
 * Purpose of this "program" is to write its PID to stdout so that
 * it can be read by a Java program which then can shutdown this
 * process gently by sending for example SIGINT to it.
 * After printig its PID the process executes the program given
 * as argument.
 */
int main(int argc, char *argv[]) {
  if(argc < 3) {
    fprintf(stderr,"Usage: %s <program> <name> [arg] ...\n", argv[0]);
    return -1;
  }

  /* Write the PID of the process to stdout */
  fprintf(stdout,"%i\n", getpid());

  /* Flush the buffers */
  fflush(NULL);

  /*
   * Execute the program (specified as file or full path) given as first
   * argument in the current process.
   */ 
  return execvp(argv[1], argv + 2);
}

假设上面的代码被编译并且可执行文件被复制到/usr/local/bin/jpwrapper，它可以被Java用来运行一个像ls -l /dev这样的本地进程，在进程启动时打印出PID，打印它的stdout，然后再次打印PID它终止了：

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class PID {

    public static void main(final String[] args) throws Exception {
        final Process process = Runtime.getRuntime().exec(new String[] {
                "/usr/local/bin/jpwrapper",
                "/bin/ls", "ls", "-l", "/dev"});

        String pid = null;
        try (final BufferedReader reader = new BufferedReader(
                new InputStreamReader(process.getInputStream()))) {
            // First line of output from the wrapper is the PID
            String line = reader.readLine();
            pid = line;
            System.out.println(String.format(
                    "Process with PID %s started", pid));

            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        }

        final int exitCode = process.waitFor();
        System.out.println(String.format(
                "Process with PID %s terminated with exit code %s", 
                pid, exitCode));
    }

}

但是，就像我在评论中已经承认的那样，从 UnixProcess 获取 PID 更容易（但也很麻烦）。