Как закончить дерево процессов с Java?

Question

Я использую команду Runtime.getRuntime(). Exec() в Java, чтобы запустить командный файл, который, в свою очередь, запускает другой процесс для платформы Windows.

javaw.exe(Process1) 
|___xyz.bat(Process2) 
     |___javaw.exe(Process3) 

Runtime.getRuntime(). Exec() возвращает объект процесса, который имеет метод уничтожения, но когда я использую уничтожить(), он убивает только xyz.bat и уходит к югу от процесса оборванных пакетного файла в ,

Есть ли чистый способ в Java, чтобы уничтожить дерево процессов, начиная с пакетного процесса, как root?

* Я не могу использовать любые пользовательские библиотеки \ Избавиться от пакетного файла, чтобы обойти этот вопрос

Answer 1

Это не возможно с помощью стандартного Java API (см редактирования в конце поста для обновления, который изменяет это). Вам понадобится некоторый собственный код некоторого разнообразия. Используя ЮНА, я использовал код, который выглядит следующим образом:

public class Win32Process 
{ 
    WinNT.HANDLE handle; 
    int pid; 

    Win32Process (int pid) throws IOException 
    { 
     handle = Kernel32.INSTANCE.OpenProcess ( 
       0x0400| /* PROCESS_QUERY_INFORMATION */ 
       0x0800| /* PROCESS_SUSPEND_RESUME */ 
       0x0001| /* PROCESS_TERMINATE */ 
       0x00100000 /* SYNCHRONIZE */, 
       false, 
       pid); 
     if (handle == null) 
      throw new IOException ("OpenProcess failed: " + 
        Kernel32Util.formatMessageFromLastErrorCode (Kernel32.INSTANCE.GetLastError())); 
     this.pid = pid; 
    } 

    @Override 
    protected void finalize() throws Throwable 
    { 
     Kernel32.INSTANCE.CloseHandle (handle); 
    } 

    public void terminate() 
    { 
     Kernel32.INSTANCE.TerminateProcess (handle, 0); 
    } 

    public List<Win32Process> getChildren() throws IOException 
    { 
     ArrayList<Win32Process> result = new ArrayList<Win32Process>(); 
     WinNT.HANDLE hSnap = KernelExtra.INSTANCE.CreateToolhelp32Snapshot (KernelExtra.TH32CS_SNAPPROCESS, new DWORD(0)); 
     KernelExtra.PROCESSENTRY32.ByReference ent = new KernelExtra.PROCESSENTRY32.ByReference(); 
     if (!KernelExtra.INSTANCE.Process32First (hSnap, ent)) return result; 
     do { 
      if (ent.th32ParentProcessID.intValue() == pid) result.add (new Win32Process (ent.th32ProcessID.intValue())); 
     } while (KernelExtra.INSTANCE.Process32Next (hSnap, ent)); 
     Kernel32.INSTANCE.CloseHandle (hSnap); 
     return result; 
    } 

}

Этот код использует следующие ЮНА заявления, которые не включены в стандартную библиотеку ЮНА:

public interface KernelExtra extends StdCallLibrary { 

    /** 
    * Includes all heaps of the process specified in th32ProcessID in the snapshot. To enumerate the heaps, see 
    * Heap32ListFirst. 
    */ 
    WinDef.DWORD TH32CS_SNAPHEAPLIST = new WinDef.DWORD(0x00000001); 

    /** 
    * Includes all processes in the system in the snapshot. To enumerate the processes, see Process32First. 
    */ 
    WinDef.DWORD TH32CS_SNAPPROCESS = new WinDef.DWORD(0x00000002); 

    /** 
    * Includes all threads in the system in the snapshot. To enumerate the threads, see Thread32First. 
    */ 
    WinDef.DWORD TH32CS_SNAPTHREAD = new WinDef.DWORD(0x00000004); 

    /** 
    * Includes all modules of the process specified in th32ProcessID in the snapshot. To enumerate the modules, see 
    * Module32First. If the function fails with ERROR_BAD_LENGTH, retry the function until it succeeds. 
    */ 
    WinDef.DWORD TH32CS_SNAPMODULE = new WinDef.DWORD(0x00000008); 

    /** 
    * Includes all 32-bit modules of the process specified in th32ProcessID in the snapshot when called from a 64-bit 
    * process. This flag can be combined with TH32CS_SNAPMODULE or TH32CS_SNAPALL. If the function fails with 
    * ERROR_BAD_LENGTH, retry the function until it succeeds. 
    */ 
    WinDef.DWORD TH32CS_SNAPMODULE32 = new WinDef.DWORD(0x00000010); 

    /** 
    * Includes all processes and threads in the system, plus the heaps and modules of the process specified in th32ProcessID. 
    */ 
    WinDef.DWORD TH32CS_SNAPALL  = new WinDef.DWORD((TH32CS_SNAPHEAPLIST.intValue() | 
      TH32CS_SNAPPROCESS.intValue() | TH32CS_SNAPTHREAD.intValue() | TH32CS_SNAPMODULE.intValue())); 

    /** 
    * Indicates that the snapshot handle is to be inheritable. 
    */ 
    WinDef.DWORD TH32CS_INHERIT  = new WinDef.DWORD(0x80000000); 

    /** 
    * Describes an entry from a list of the processes residing in the system address space when a snapshot was taken. 
    */ 
    public static class PROCESSENTRY32 extends Structure { 

     public static class ByReference extends PROCESSENTRY32 implements Structure.ByReference { 
      public ByReference() { 
      } 

      public ByReference(Pointer memory) { 
       super(memory); 
      } 
     } 

     public PROCESSENTRY32() { 
      dwSize = new WinDef.DWORD(size()); 
     } 

     public PROCESSENTRY32(Pointer memory) { 
      useMemory(memory); 
      read(); 
     } 

     /** 
     * The size of the structure, in bytes. Before calling the Process32First function, set this member to 
     * sizeof(PROCESSENTRY32). If you do not initialize dwSize, Process32First fails. 
     */ 
     public WinDef.DWORD dwSize; 

     /** 
     * This member is no longer used and is always set to zero. 
     */ 
     public WinDef.DWORD cntUsage; 

     /** 
     * The process identifier. 
     */ 
     public WinDef.DWORD th32ProcessID; 

     /** 
     * This member is no longer used and is always set to zero. 
     */ 
     public BaseTSD.ULONG_PTR th32DefaultHeapID; 

     /** 
     * This member is no longer used and is always set to zero. 
     */ 
     public WinDef.DWORD th32ModuleID; 

     /** 
     * The number of execution threads started by the process. 
     */ 
     public WinDef.DWORD cntThreads; 

     /** 
     * The identifier of the process that created this process (its parent process). 
     */ 
     public WinDef.DWORD th32ParentProcessID; 

     /** 
     * The base priority of any threads created by this process. 
     */ 
     public WinDef.LONG pcPriClassBase; 

     /** 
     * This member is no longer used, and is always set to zero. 
     */ 
     public WinDef.DWORD dwFlags; 

     /** 
     * The name of the executable file for the process. To retrieve the full path to the executable file, call the 
     * Module32First function and check the szExePath member of the MODULEENTRY32 structure that is returned. 
     * However, if the calling process is a 32-bit process, you must call the QueryFullProcessImageName function to 
     * retrieve the full path of the executable file for a 64-bit process. 
     */ 
     public char[] szExeFile = new char[WinDef.MAX_PATH]; 
    } 


    // the following methods are in kernel32.dll, but not declared there in the current version of Kernel32: 

    /** 
    * Takes a snapshot of the specified processes, as well as the heaps, modules, and threads used by these processes. 
    * 
    * @param dwFlags 
    * The portions of the system to be included in the snapshot. 
    * 
    * @param th32ProcessID 
    * The process identifier of the process to be included in the snapshot. This parameter can be zero to indicate 
    * the current process. This parameter is used when the TH32CS_SNAPHEAPLIST, TH32CS_SNAPMODULE, 
    * TH32CS_SNAPMODULE32, or TH32CS_SNAPALL value is specified. Otherwise, it is ignored and all processes are 
    * included in the snapshot. 
    * 
    * If the specified process is the Idle process or one of the CSRSS processes, this function fails and the last 
    * error code is ERROR_ACCESS_DENIED because their access restrictions prevent user-level code from opening them. 
    * 
    * If the specified process is a 64-bit process and the caller is a 32-bit process, this function fails and the 
    * last error code is ERROR_PARTIAL_COPY (299). 
    * 
    * @return 
    * If the function succeeds, it returns an open handle to the specified snapshot. 
    * 
    * If the function fails, it returns INVALID_HANDLE_VALUE. To get extended error information, call GetLastError. 
    * Possible error codes include ERROR_BAD_LENGTH. 
    */ 
    public WinNT.HANDLE CreateToolhelp32Snapshot(WinDef.DWORD dwFlags, WinDef.DWORD th32ProcessID); 

    /** 
    * Retrieves information about the first process encountered in a system snapshot. 
    * 
    * @param hSnapshot A handle to the snapshot returned from a previous call to the CreateToolhelp32Snapshot function. 
    * @param lppe A pointer to a PROCESSENTRY32 structure. It contains process information such as the name of the 
    * executable file, the process identifier, and the process identifier of the parent process. 
    * @return 
    * Returns TRUE if the first entry of the process list has been copied to the buffer or FALSE otherwise. The 
    * ERROR_NO_MORE_FILES error value is returned by the GetLastError function if no processes exist or the snapshot 
    * does not contain process information. 
    */ 
    public boolean Process32First(WinNT.HANDLE hSnapshot, KernelExtra.PROCESSENTRY32.ByReference lppe); 

    /** 
    * Retrieves information about the next process recorded in a system snapshot. 
    * 
    * @param hSnapshot A handle to the snapshot returned from a previous call to the CreateToolhelp32Snapshot function. 
    * @param lppe A pointer to a PROCESSENTRY32 structure. 
    * @return 
    * Returns TRUE if the next entry of the process list has been copied to the buffer or FALSE otherwise. The 
    * ERROR_NO_MORE_FILES error value is returned by the GetLastError function if no processes exist or the snapshot 
    * does not contain process information. 
    */ 
    public boolean Process32Next(WinNT.HANDLE hSnapshot, KernelExtra.PROCESSENTRY32.ByReference lppe); 


} 

You затем может использовать метод getChildren() для получения списка дочерних элементов, прекращения родительского элемента и последующего рекурсивного завершения работы с дочерними элементами.

Я считаю, что вы можете добавить PID java.lang.Process с использованием отражения (я этого еще не сделал, я переключился на создание процессов самостоятельно с помощью Win32 API, чтобы у меня был больше контроля над ним).

Так положить его вместе, вам нужно что-то вроде:

int pid = (some code to extract PID from the process you want to kill); 
Win32Process process = new Win32Process(pid); 
kill(process); 

public void kill(Win32Process target) throws IOException 
{ 
    List<Win32Process> children = target.getChildren(); 
    target.terminateProcess(); 
    for (Win32Process child : children) kill(child); 
} 

Edit

Оказывается, что именно этот недостаток API Java является фиксированы в Java 9. См предварительный просмотр документация Java 9 here (если правильная страница не загружается, вам необходимо посмотреть на интерфейс java.lang.ProcessHandle). Для требования вышеуказанного вопроса, то код будет выглядеть примерно так:

Process child = ...; 
kill (child.toHandle()); 

public void kill (ProcessHandle handle) 
{ 
    handle.descendants().forEach((child) -> kill(child)); 
    handle.destroy(); 
} 

(Обратите внимание, что это не проверено - я не перешел на Java-пока, но я активно читал об этом)

Answer 2

Вы не можете убить дерево процесса для окон с использованием JDK. Вам нужно полагаться на WinAPI. Вам придется прибегать к собственным командам или библиотекам JNI, все из которых зависят от платформы и сложнее, чем просто решение Java.

Ссылка образец JNI Example

Answer 3

Альтернативное решение, если вы управляете дочерним процессом, а также командный файл, должно быть связано с тем, чтобы дочерний процесс создавал поток, открывал ServerSocket, слушал подключение к нему и вызывал System.exit() если он получает на нем правильный пароль.

Возможны осложнения, если вам нужно несколько одновременных экземпляров; в этот момент вам потребуется какой-то способ распределения номеров портов.

Answer 4

Вот еще один вариант. Используйте этот сценарий powershell для выполнения вашего битового скрипта. Когда вы хотите убить дерево, завершите процесс скрипта powershell и он автоматически выполнит taskkill на этом подпроцессе. У меня есть вызов taskkill дважды, потому что в некоторых случаях он не берется с первой попытки.

Param(
    [string]$path 
) 

$p = [Diagnostics.Process]::Start("$path").Id 

try { 
    while($true) { 
     sleep 100000 
    } 
} finally { 
    taskkill /pid $p 
    taskkill /pid $p 
} 

Answer 5

С java 9, убивающий основной процесс, уничтожает все дерево процессов. Вы могли бы сделать что-то вроде этого:

Process ptree = Runtime.getRuntime().exec("cmd.exe","/c","xyz.bat"); 
// wait logic 
ptree.destroy(); 

Пожалуйста, обратите внимание на эту blog и проверить сделки с процессом деревья например.