这是不可能的使用标准的Java API（请参阅编辑结尾的更新，以改变这一点）。 你将需要一些本地代码的一些变化。 使用JNA，我使用的代码如下所示：

 public class Win32Process { WinNT.HANDLE handle; int pid; Win32Process (int pid) throws IOException { handle = coreel32.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: " + coreel32Util.formatMessageFromLastErrorCode (coreel32.INSTANCE.GetLastError ())); this.pid = pid; } @Override protected void finalize () throws Throwable { coreel32.INSTANCE.CloseHandle (handle); } public void terminate () { coreel32.INSTANCE.TerminateProcess (handle, 0); } public List<Win32Process> getChildren () throws IOException { ArrayList<Win32Process> result = new ArrayList<Win32Process> (); WinNT.HANDLE hSnap = coreelExtra.INSTANCE.CreateToolhelp32Snapshot (coreelExtra.TH32CS_SNAPPROCESS, new DWORD(0)); coreelExtra.PROCESSENTRY32.ByReference ent = new coreelExtra.PROCESSENTRY32.ByReference (); if (!coreelExtra.INSTANCE.Process32First (hSnap, ent)) return result; do { if (ent.th32ParentProcessID.intValue () == pid) result.add (new Win32Process (ent.th32ProcessID.intValue ())); } while (coreelExtra.INSTANCE.Process32Next (hSnap, ent)); coreel32.INSTANCE.CloseHandle (hSnap); return result; } 

}

此代码使用未包含在标准JNA库中的以下JNA声明：

 public interface coreelExtra 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 * modulee32First. 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 th32moduleeID; /** * 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 * modulee32First 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 coreel32: /** * 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, coreelExtra.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, coreelExtra.PROCESSENTRY32.ByReference lppe); } 

然后，您可以使用'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); } 

编辑

事实证明，Java API的这个特殊缺点正在Java 9中得到解决。请参阅此处的Java 9文档的预览（如果正确的页面未加载，则需要查看java.lang.ProcessHandle接口） 。 对于上述问题的要求，代码现在看起来像这样：

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

（请注意，这没有经过测试 – 我还没有切换到Java 9，但正在积极阅读）

另一种解决方案是，如果你控制子进程以及批处理文件，那么应该让子进程创建一个线程，打开一个serverSocket，监听它的连接，如果它接收到一个System.exit（）正确的密码就可以了。

如果您需要多个同时发生的事件，可能会有复杂性 那么你需要一些分配端口号的方法。

您不能使用JDK杀死Windows的进程树。 您需要依赖WinAPI.You将不得不求助于本地命令或JNI库，所有这些都是平台相关的，比纯粹的Java解决方案更复杂。

示例链接JNI示例

这是另一种选择。 使用这个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 } 

用java 9，查杀主进程杀死整个进程树。 你可以做这样的事情：

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

请看看这个博客 ，看看处理树的例子。