我在Java中使用Runtime.getRuntime（）。exec（）命令来启动一个批处理文件，该文件反过来启动Windows平台的另一个进程。我如何从Java终止进程树？
javaw.exe(Process1)
|___xyz.bat(Process2)
|___javaw.exe(Process3)
调用Runtime.getRuntime（）。EXEC（）返回其具有破坏方法的过程对象，但是当我使用破坏（），它杀死只有xyz.bat并离开批处理文件的子过程的悬空。
在Java中是否有一种干净的方式销毁以批处理作为根开始的进程树？
* I不能使用任何自定义库\摆脱批处理文件来绕过问题
这是不可能的使用标准Java API（见在帖子末尾编辑为改变此更新）。你将需要一些种类的本地代码。使用JNA，我使用的代码看起来像这样：
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;
}
}
该代码使用的是不包括在标准JNA库中的以下JNA声明：
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);
}
你然后可以使用'getChildren（）'方法来获取子项列表，终止父项，然后递归地终止子项。我相信你可以额外使用反射的java.lang.Process的PID（但我没有这样做;但是我改用自己使用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文档here（如果没有正确的页面加载，则需要查看java.lang.ProcessHandle接口）。对于上述问题的要求，代码现在看起来是这样的：
Process child = ...;
kill (child.toHandle());
public void kill (ProcessHandle handle)
{
handle.descendants().forEach((child) -> kill(child));
handle.destroy();
}
（请注意，这不是测试 - 我还没有切换到Java 9还没有，但我积极地阅读它）
你不能杀使用JDK窗口进程树。您需要依赖WinAPI.You将不得不求助于本地命令或JNI库，所有这些都是平台相关的，并且比纯Java解决方案更复杂。
样本链接JNI Example
不幸的是，我不能使用任何外部或自定义libraries.However，但我可以更改批处理文件。是否有一种方法来捕获由Process.destroy（）从Java发送的批处理中的术语信号？然后用它来杀死子进程？ – srami 2012-04-12 13:24:27
您可以使用批处理文件管理进程。请查看可供管理的几个选项的链接。 http://www.robvanderwoude.com/processes.php – Phani 2012-04-12 13:28:37
我不相信有什么办法让Windows批处理文件捕获这样的信号 - Java本身使用TerminateProcess，它直接杀死进程而不发送首先发信号给它。此外，如果子进程当前正在运行，批处理文件必须等待它退出才能执行其他任何操作，并且Java无法终止子进程。如果你想这样做，你将不得不使用外部库。 – Jules 2012-04-12 13:40:01
另一种解决方案是，如果你控制子进程以及批处理文件，可以让子进程创建一个线程，打开一个ServerSocket，监听一个连接，并调用System.exit（）如果它收到一个正确的密码。
如果您需要多个同时发生的事件，可能会出现复杂情况;那时你需要一些分配端口号的方法。
这是另一种选择。使用这个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();
请看一看这个blog，并检查了处理进程树例子。
我可以问为什么没有自定义库的要求？根据我的经验，这样的需求通常存在非常差的原因，并且可能需要解释需要库的理由（在这种情况下，Java平台缺少一个必需的功能，即枚举父进程的子进程）。 – Jules 2012-04-12 14:01:37