有谁知道如何使用Java获取当前打开的窗口或本地计算机的进程？
我想做的是：像Windows Taskmanager一样列出当前打开的任务，窗口或打开的进程，但是使用多平台方法-如果可能的话，仅使用Java。
这是从命令" ps -e"解析进程列表的另一种方法：
1
2
3
4
5
6
7
8
9
10
11
12
| try {
String line;
Process p = Runtime.getRuntime().exec("ps -e");
BufferedReader input =
new BufferedReader(new InputStreamReader(p.getInputStream()));
while ((line = input.readLine()) != null) {
System.out.println(line); //<-- Parse data here.
}
input.close();
} catch (Exception err) {
err.printStackTrace();
} |
如果您使用的是Windows，则应更改以下行：" Process p = Runtime.getRun ..."等(第三行)，如下所示：
1
2
| Process p = Runtime.getRuntime().exec
(System.getenv("windir") +"\\\\system32\\\"+"tasklist.exe"); |
希望该信息对您有所帮助！
最后，使用Java 9+，可以使用ProcessHandle：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| public static void main(String[] args) {
ProcessHandle.allProcesses()
.forEach(process -> System.out.println(processDetails(process)));
}
private static String processDetails(ProcessHandle process) {
return String.format("%8d %8s %10s %26s %-40s",
process.pid(),
text(process.parent().map(ProcessHandle::pid)),
text(process.info().user()),
text(process.info().startInstant()),
text(process.info().commandLine()));
}
private static String text(Optional< ? > optional) {
return optional.map(Object::toString).orElse("-");
} |
输出：
1
2
3
4
5
| 1 - root 2017-11-19T18:01:13.100Z /sbin/init
...
639 1325 www-data 2018-12-04T06:35:58.680Z /usr/sbin/apache2 -k start
...
23082 11054 huguesm 2018-12-04T10:24:22.100Z /.../java ProcessListDemo |
在Windows上，还有使用JNA的替代方法：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| import com.sun.jna.Native;
import com.sun.jna.platform.win32.*;
import com.sun.jna.win32.W32APIOptions;
public class ProcessList {
public static void main(String[] args) {
WinNT winNT = (WinNT) Native.loadLibrary(WinNT.class, W32APIOptions.UNICODE_OPTIONS);
WinNT.HANDLE snapshot = winNT.CreateToolhelp32Snapshot(Tlhelp32.TH32CS_SNAPPROCESS, new WinDef.DWORD(0));
Tlhelp32.PROCESSENTRY32.ByReference processEntry = new Tlhelp32.PROCESSENTRY32.ByReference();
while (winNT.Process32Next(snapshot, processEntry)) {
System.out.println(processEntry.th32ProcessID +"\\t" + Native.toString(processEntry.szExeFile));
}
winNT.CloseHandle(snapshot);
}
} |
我能想到的唯一方法是调用一个为您完成任务的命令行应用程序，然后对输出进行屏幕抓取(例如Linux的ps和Window的任务列表)。
不幸的是，这意味着您必须编写一些解析例程才能从两者中读取数据。
1
2
3
4
5
| Process proc = Runtime.getRuntime().exec ("tasklist.exe");
InputStream procOutput = proc.getInputStream ();
if (0 == proc.waitFor ()) {
// TODO scan the procOutput for your data
} |
YAJSW(还有另一个Java服务包装程序)看起来像它的org.rzo.yajsw.os.TaskList接口的基于JNA的实现，适用于win32，linux，bsd和solaris，并且已获得LGPL许可。我没有尝试直接调用此代码，但当我过去使用YAJSW时，它的工作原理非常好，因此您不必担心太多。
您可以使用jProcesses轻松检索正在运行的进程的列表
1
2
3
4
5
6
7
8
9
| List<ProcessInfo> processesList = JProcesses.getProcessList();
for (final ProcessInfo processInfo : processesList) {
System.out.println("Process PID:" + processInfo.getPid());
System.out.println("Process Name:" + processInfo.getName());
System.out.println("Process Used Time:" + processInfo.getTime());
System.out.println("Full command:" + processInfo.getCommand());
System.out.println("------------------");
} |
这对于具有捆绑JRE的应用程序可能很有用：我扫描从以下位置运行应用程序的文件夹名称：因此，如果您正在从以下位置运行应用程序：
1
| C:\\Dev\\build\\SomeJavaApp\\jre-9.0.1\\bin\\javaw.exe |
那么您可以通过以下方式找到它是否已经在J9中运行：
1
2
3
4
5
6
7
8
9
| public static void main(String[] args) {
AtomicBoolean isRunning = new AtomicBoolean(false);
ProcessHandle.allProcesses()
.filter(ph -> ph.info().command().isPresent() && ph.info().command().get().contains("SomeJavaApp"))
.forEach((process) -> {
isRunning.set(true);
});
if (isRunning.get()) System.out.println("SomeJavaApp is running already");
} |
对于Windows，我使用以下命令：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| Process process = new ProcessBuilder("tasklist.exe","/fo","csv","/nh").start();
new Thread(() -> {
Scanner sc = new Scanner(process.getInputStream());
if (sc.hasNextLine()) sc.nextLine();
while (sc.hasNextLine()) {
String line = sc.nextLine();
String[] parts = line.split(",");
String unq = parts[0].substring(1).replaceFirst(".$","");
String pid = parts[1].substring(1).replaceFirst(".$","");
System.out.println(unq +"" + pid);
}
}).start();
process.waitFor();
System.out.println("Done"); |
尚无与平台无关的方法。在Java的1.6版本中，添加了"桌面"类，该类允许以可移植的方式浏览，编辑，邮寄，打开和打印URI。可能有一天有可能将此课程扩展到支持流程，但我对此表示怀疑。
如果您只是对Java进程感到好奇，则可以使用java.lang.management api来获取JVM上的线程/内存信息。
最好选择使用代码来解析Linux的ps aux和Windows的tasklist，直到出现更通用的东西。
对于Windows，您可以参考：http://www.rgagnon.com/javadetails/java-0593.html
Linux也可以通过grep用管道传输ps aux的结果，这将使处理/搜索变得快速而容易。我相信您也可以在Windows上找到类似的东西。
1
2
3
4
5
6
7
8
9
| String line;
Process process = Runtime.getRuntime().exec("ps -e");
process.getOutputStream().close();
BufferedReader input =
new BufferedReader(new InputStreamReader(process.getInputStream()));
while ((line = input.readLine()) != null) {
System.out.println(line); //<-- Parse data here.
}
input.close(); |
我们必须使用process.getOutputStream.close()，否则它将被锁定在while循环中。
以下程序仅与Java 9+版本兼容...
要获取CurrentProcess信息，
1
2
3
4
5
6
7
8
| public class CurrentProcess {
public static void main(String[] args) {
ProcessHandle handle = ProcessHandle.current();
System.out.println("Current Running Process Id:"+handle.pid());
ProcessHandle.Info info = handle.info();
System.out.println("ProcessHandle.Info :"+info);
}
} |
对于所有正在运行的进程，
1
2
3
4
5
6
7
8
9
10
| import java.util.List;
import java.util.stream.Collectors;
public class AllProcesses {
public static void main(String[] args) {
ProcessHandle.allProcesses().forEach(processHandle -> {
System.out.println(processHandle.pid()+""+processHandle.info());
});
}
} |
这是我的函数代码，该函数获取任务并获取其名称，还将它们添加到列表中以从列表进行访问。它使用数据创建临时文件，读取文件并获得带有.exe后缀的任务名称，并在程序以System.exit(0)退出时安排要删除的文件，并且还隐藏了用于获取任务以及java.exe，以便用户不会意外终止一起运行该程序的进程。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
| private static final DefaultListModel tasks = new DefaultListModel();
public static void getTasks()
{
new Thread()
{
@Override
public void run()
{
try
{
File batchFile = File.createTempFile("batchFile",".bat");
File logFile = File.createTempFile("log",".txt");
String logFilePath = logFile.getAbsolutePath();
try (PrintWriter fileCreator = new PrintWriter(batchFile))
{
String[] linesToPrint = {"@echo off","tasklist.exe >>" + logFilePath,"exit"};
for(String string:linesToPrint)
{
fileCreator.println(string);
}
fileCreator.close();
}
int task = Runtime.getRuntime().exec(batchFile.getAbsolutePath()).waitFor();
if(task == 0)
{
FileReader fileOpener = new FileReader(logFile);
try (BufferedReader reader = new BufferedReader(fileOpener))
{
String line;
while(true)
{
line = reader.readLine();
if(line != null)
{
if(line.endsWith("K"))
{
if(line.contains(".exe"))
{
int index = line.lastIndexOf(".exe", line.length());
String taskName = line.substring(0, index + 4);
if(! taskName.equals("tasklist.exe") && ! taskName.equals("cmd.exe") && ! taskName.equals("java.exe"))
{
tasks.addElement(taskName);
}
}
}
}
else
{
reader.close();
break;
}
}
}
}
batchFile.deleteOnExit();
logFile.deleteOnExit();
}
catch (FileNotFoundException ex)
{
Logger.getLogger(Functions.class.getName()).log(Level.SEVERE, null, ex);
}
catch (IOException | InterruptedException ex)
{
Logger.getLogger(Functions.class.getName()).log(Level.SEVERE, null, ex);
}
catch (NullPointerException ex)
{
// This stops errors from being thrown on an empty line
}
}
}.start();
}
public static void killTask(String taskName)
{
new Thread()
{
@Override
public void run()
{
try
{
Runtime.getRuntime().exec("taskkill.exe /IM" + taskName);
}
catch (IOException ex)
{
Logger.getLogger(Functions.class.getName()).log(Level.SEVERE, null, ex);
}
}
}.start();
} |
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
| package com.vipul;
import java.applet.Applet;
import java.awt.Checkbox;
import java.awt.Choice;
import java.awt.Font;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
public class BatchExecuteService extends Applet {
public Choice choice;
public void init()
{
setFont(new Font("Helvetica", Font.BOLD, 36));
choice = new Choice();
}
public static void main(String[] args) {
BatchExecuteService batchExecuteService = new BatchExecuteService();
batchExecuteService.run();
}
List<String> processList = new ArrayList<String>();
public void run() {
try {
Runtime runtime = Runtime.getRuntime();
Process process = runtime.exec("D:\\\\server.bat");
process.getOutputStream().close();
InputStream inputStream = process.getInputStream();
InputStreamReader inputstreamreader = new InputStreamReader(
inputStream);
BufferedReader bufferedrReader = new BufferedReader(
inputstreamreader);
BufferedReader bufferedrReader1 = new BufferedReader(
inputstreamreader);
String strLine ="";
String x[]=new String[100];
int i=0;
int t=0;
while ((strLine = bufferedrReader.readLine()) != null)
{
// System.out.println(strLine);
String[] a=strLine.split(",");
x[i++]=a[0];
}
// System.out.println("Length :"+i);
for(int j=2;j<i;j++)
{
System.out.println(x[j]);
}
}
catch (IOException ioException)
{
ioException.printStackTrace();
}
}
} |
1
| You can create batch file like |
TASKLIST /v /FI"STATUS eq running" /FO"CSV" /FI"Username eq LHPL002\\soft" /FI"MEMUSAGE gt 10000" /FI"Windowtitle ne N/A" /NH
