Wie erhalte ich die PID des Prozesses, den ich gerade im Java-Programm gestartet habe?

Ich habe einen Prozess mit folgendem Code gestartet

 ProcessBuilder pb = new ProcessBuilder("cmd", "/c", "path");
 try {
     Process p = pb.start();       
 } 
 catch (IOException ex) {}

Jetzt muss ich die PID des Prozesses kennen, den ich gerade gestartet habe.

Seit Java 9 Klasse Process hat eine neue Methode long pid()also ist es so einfach wie

ProcessBuilder pb = new ProcessBuilder("cmd", "/c", "path");
try {
    Process p = pb.start();
    long pid = p.pid();      
} catch (IOException ex) {
    // ...
}

Dafür gibt es noch keine öffentliche API. siehe Sonne Fehler 4244896Sonne Fehler 4250622

Als Problemumgehung:

Runtime.exec(...)

gibt ein Objekt vom Typ zurück

java.lang.Process

Die Process-Klasse ist abstrakt, und was Sie zurückerhalten, ist eine Unterklasse von Process, die für Ihr Betriebssystem entwickelt wurde. Zum Beispiel auf Macs kehrt es zurück java.lang.UnixProcess die ein privates Feld namens hat pid. Mit Reflection können Sie den Wert dieses Felds leicht abrufen. Dies ist zugegebenermaßen ein Hack, aber es könnte helfen. Was braucht man den PID denn überhaupt?

Diese Seite hat das HOWTO:

http://www.golesny.de/p/code/javagetpid

Unter Windows:

Runtime.exec(..)

Gibt eine Instanz von „java.lang.Win32Process“) ODER „java.lang.ProcessImpl“ zurück

Beide haben ein privates Feld “Handle”.

Dies ist ein Betriebssystem-Handle für den Prozess. Sie müssen diese + Win32-API verwenden, um PID abzufragen. Auf dieser Seite finden Sie Einzelheiten dazu.

Im Unix-System (Linux & Mac)

 public static synchronized long getPidOfProcess(Process p) {
    long pid = -1;

    try {
      if (p.getClass().getName().equals("java.lang.UNIXProcess")) {
        Field f = p.getClass().getDeclaredField("pid");
        f.setAccessible(true);
        pid = f.getLong(p);
        f.setAccessible(false);
      }
    } catch (Exception e) {
      pid = -1;
    }
    return pid;
  }

Enthalten jna (sowohl “JNA” als auch “JNA Platform”) in Ihrer Bibliothek und verwenden Sie diese Funktion:

import com.sun.jna.Pointer;
import com.sun.jna.platform.win32.Kernel32;
import com.sun.jna.platform.win32.WinNT;
import java.lang.reflect.Field;

public static long getProcessID(Process p)
    {
        long result = -1;
        try
        {
            //for windows
            if (p.getClass().getName().equals("java.lang.Win32Process") ||
                   p.getClass().getName().equals("java.lang.ProcessImpl")) 
            {
                Field f = p.getClass().getDeclaredField("handle");
                f.setAccessible(true);              
                long handl = f.getLong(p);
                Kernel32 kernel = Kernel32.INSTANCE;
                WinNT.HANDLE hand = new WinNT.HANDLE();
                hand.setPointer(Pointer.createConstant(handl));
                result = kernel.GetProcessId(hand);
                f.setAccessible(false);
            }
            //for unix based operating systems
            else if (p.getClass().getName().equals("java.lang.UNIXProcess")) 
            {
                Field f = p.getClass().getDeclaredField("pid");
                f.setAccessible(true);
                result = f.getLong(p);
                f.setAccessible(false);
            }
        }
        catch(Exception ex)
        {
            result = -1;
        }
        return result;
    }

Sie können JNA auch von herunterladen Hier und JNA-Plattform von Hier.

Ich glaube, ich habe eine Lösung gefunden, die ziemlich kugelsicher aussieht, während sie auf den meisten Plattformen funktioniert. Hier ist die Idee:

1. Erstellen Sie einen JVM-weiten Mutex, den Sie erwerben, bevor Sie einen neuen Prozess erzeugen/einen Prozess beenden
2. Verwenden Sie plattformabhängigen Code, um die Liste der untergeordneten Prozesse + PIDs Ihres JVM-Prozesses abzurufen
3. Spawnen Sie einen neuen Prozess
4. Erwerben Sie eine neue Liste von untergeordneten Prozessen + PIDs und vergleichen Sie sie mit der vorherigen Liste. Der Neue ist dein Typ.

Da Sie nur nach untergeordneten Prozessen suchen, kann Ihnen kein anderer Prozess auf derselben Maschine Unrecht tun. JVM-weiter Mutex gibt Ihnen dann die Gewissheit, dass der neue Prozess der richtige ist.

Das Lesen der untergeordneten Prozessliste ist einfacher als das Abrufen der PID von Prozessobjekten, da es keine WIN-API-Aufrufe unter Windows erfordert und, was noch wichtiger ist, es wurde bereits in mehreren Bibliotheken durchgeführt.

Unten ist eine Implementierung der obigen Idee mit JavaSysMon Bücherei. Es

class UDKSpawner {

    private int uccPid;
    private Logger uccLog;

    /**
     * Mutex that forces only one child process to be spawned at a time. 
     * 
     */
    private static final Object spawnProcessMutex = new Object();

    /**
     * Spawns a new UDK process and sets {@link #uccPid} to it's PID. To work correctly,
     * the code relies on the fact that no other method in this JVM runs UDK processes and
     * that no method kills a process unless it acquires lock on spawnProcessMutex.
     * @param procBuilder
     * @return 
     */
    private Process spawnUDK(ProcessBuilder procBuilder) throws IOException {
        synchronized (spawnProcessMutex){            
            JavaSysMon monitor = new JavaSysMon();
            DirectUDKChildProcessVisitor beforeVisitor = new DirectUDKChildProcessVisitor();
            monitor.visitProcessTree(monitor.currentPid(), beforeVisitor);
            Set<Integer> alreadySpawnedProcesses = beforeVisitor.getUdkPids();

            Process proc = procBuilder.start();

            DirectUDKChildProcessVisitor afterVisitor = new DirectUDKChildProcessVisitor();
            monitor.visitProcessTree(monitor.currentPid(), afterVisitor);
            Set<Integer> newProcesses = afterVisitor.getUdkPids();

            newProcesses.removeAll(alreadySpawnedProcesses);

            if(newProcesses.isEmpty()){
                uccLog.severe("There is no new UKD PID.");
            }
            else if(newProcesses.size() > 1){
                uccLog.severe("Multiple new candidate UDK PIDs");
            } else {
                uccPid = newProcesses.iterator().next();
            }
            return proc;
        }
    }    

    private void killUDKByPID(){
        if(uccPid < 0){
            uccLog.severe("Cannot kill UCC by PID. PID not set.");
            return;
        }
        synchronized(spawnProcessMutex){
            JavaSysMon monitor = new JavaSysMon();
            monitor.killProcessTree(uccPid, false);
        }
    }

    private static class DirectUDKChildProcessVisitor implements ProcessVisitor {
        Set<Integer> udkPids = new HashSet<Integer>();

        @Override
        public boolean visit(OsProcess op, int i) {
            if(op.processInfo().getName().equals("UDK.exe")){
                udkPids.add(op.processInfo().getPid());
            }
            return false;
        }

        public Set<Integer> getUdkPids() {
            return udkPids;
        }
    }
}

In meinen Tests hatten alle IMPL-Klassen das Feld “PID”. Das hat bei mir funktioniert:

public static int getPid(Process process) {
    try {
        Class<?> cProcessImpl = process.getClass();
        Field fPid = cProcessImpl.getDeclaredField("pid");
        if (!fPid.isAccessible()) {
            fPid.setAccessible(true);
        }
        return fPid.getInt(process);
    } catch (Exception e) {
        return -1;
    }
}

Stellen Sie nur sicher, dass der zurückgegebene Wert nicht -1 ist. Wenn dies der Fall ist, analysieren Sie die Ausgabe von ps.