Java程序如何获得自己的进程ID？

如何获取Java进程的id

---

我知道有几种依赖于平台的黑客攻击，但我更喜欢一种更通用的解决方案。

不存在能够保证在所有jvm实现中工作的独立于平台的方法。

ManagementFactory.getRuntimeMXBean（）.getName（）

看起来是最好（最接近）的解决方案，通常包括PID。它很短，可能适用于广泛使用的每个实现

在linux+windows上，它返回一个类似

12345@hostname

（

12345

为流程id）。但请注意，对于该值没有任何保证：

返回表示正在运行的Java虚拟机的名称。这个 返回的名称字符串可以是任意字符串和Java虚拟字符串 机器实现可以选择嵌入特定于平台的有用信息 返回的名称字符串中的信息。每个正在运行的虚拟机 可能有不同的名字

在Java 9中可以使用新的：

long pid = ProcessHandle.current().pid();

---

这取决于你从哪里寻找信息

如果要从控制台查找信息，可以使用jps命令。该命令提供的输出类似于unixps命令，并随JDK一起提供，因为我相信是1.5

如果您从进程的角度来看，RuntimeMXBean（正如Wouter Coekaerts所说）可能是您的最佳选择。Windows上使用Sun JDK 1.6 u7的getName（）的输出格式为[PROCESS_ID]@[MACHINE_NAME]。但是，您可以尝试执行jps，并从中解析结果：

String jps = [JDK HOME] + "\\bin\\jps.exe";
Process p = Runtime.getRuntime().exec(jps);

---

如果在没有选项的情况下运行，则输出应该是进程id，后跟名称。

您可以在GitHub上查看我的项目。它跨平台（目前是Windows、Mac OSX、Linux和Solaris）提供进程id和一系列其他内容（CPU使用率、内存使用率）

试试看。非常广泛的API。Apache2许可证

私有Sigar-Sigar；
公共同步Sigar getSigar（）{
if（sigar==null）{
sigar=新的sigar（）；
}
返回信号；
}
公共发布{
如果（sigar！=null）{
sigar.close（）；
sigar=null；
}
}
公共长getPid（）{
返回getSigar（）.getPid（）；
}

对于linux中较旧的JVM

private static String getPid() throws IOException {
    byte[] bo = new byte[256];
    InputStream is = new FileInputStream("/proc/self/stat");
    is.read(bo);
    for (int i = 0; i < bo.length; i++) {
        if ((bo[i] < '0') || (bo[i] > '9')) {
            return new String(bo, 0, i);
        }
    }
    return "-1";
}

私有静态字符串getPid（）引发IOException{
字节[]bo=新字节[256]；
InputStream is=新文件InputStream（“/proc/self/stat”）；
is.read（bo）；
for（int i=0；i'9'））{
返回新字符串（bo，0，i）；
}
}
返回“-1”；
}

您可以使用。不幸的是，目前还没有通用的JNA API来获取当前进程ID，但每个平台都非常简单：

窗户 确保您有

jna platform.jar

，然后：

int pid = Kernel32.INSTANCE.GetCurrentProcessId();

Unix 宣布：

private interface CLibrary extends Library {
    CLibrary INSTANCE = (CLibrary) Native.loadLibrary("c", CLibrary.class);   
    int getpid ();
}

然后：

---

爪哇9 在Java 9下，可以使用new获取当前进程ID。首先获取当前进程的句柄，然后查询PID：

long pid = ProcessHandle.current().pid();

---

我最新发现的是，至少在linux上有一个名为

sun.java.launcher.pid的系统属性。我的计划是使用它，如果没有找到使用
jmxbean
的方法，则以下方法尝试从
java.lang.management.ManagementFactory
提取PID：

private static String getProcessId(final String fallback) {
    // Note: may fail in some JVM implementations
    // therefore fallback has to be provided

    // something like '<pid>@<hostname>', at least in SUN / Oracle JVMs
    final String jvmName = ManagementFactory.getRuntimeMXBean().getName();
    final int index = jvmName.indexOf('@');

    if (index < 1) {
        // part before '@' empty (index = 0) / '@' not found (index = -1)
        return fallback;
    }

    try {
        return Long.toString(Long.parseLong(jvmName.substring(0, index)));
    } catch (NumberFormatException e) {
        // ignore
    }
    return fallback;
}

私有静态字符串getProcessId（最终字符串回退）{
//注意：在某些JVM实现中可能会失败
//因此，必须提供后备方案
//至少在SUN/Oracle JVM中使用类似于“@”的东西
最后一个字符串jvmName=ManagementFactory.getRuntimeMXBean（）.getName（）；
final int index=jvmName.indexOf（'@'）；
如果（指数<1）{
//“@”之前的部分为空（索引=0）/“@”未找到（索引=-1）
返回回退；
}
试一试{
返回Long.toString（Long.parseLong（jvmName.substring（0，index））；
}捕获（数字格式）{
//忽略
}
返回回退；
}

例如，只需调用
getProcessId（“”
。
这里有一个后门方法，它可能不适用于所有虚拟机，但应该适用于linux和windows（）：

这是JConsole代码，可能是jps和VisualVM使用的代码。它利用来自
sun.jvmstat.monitor.*
包，来自
tool.jar

package my.code.a003.process;

import sun.jvmstat.monitor.HostIdentifier;
import sun.jvmstat.monitor.MonitorException;
import sun.jvmstat.monitor.MonitoredHost;
import sun.jvmstat.monitor.MonitoredVm;
import sun.jvmstat.monitor.MonitoredVmUtil;
import sun.jvmstat.monitor.VmIdentifier;


public class GetOwnPid {

    public static void main(String[] args) {
        new GetOwnPid().run();
    }

    public void run() {
        System.out.println(getPid(this.getClass()));
    }

    public Integer getPid(Class<?> mainClass) {
        MonitoredHost monitoredHost;
        Set<Integer> activeVmPids;
        try {
            monitoredHost = MonitoredHost.getMonitoredHost(new HostIdentifier((String) null));
            activeVmPids = monitoredHost.activeVms();
            MonitoredVm mvm = null;
            for (Integer vmPid : activeVmPids) {
                try {
                    mvm = monitoredHost.getMonitoredVm(new VmIdentifier(vmPid.toString()));
                    String mvmMainClass = MonitoredVmUtil.mainClass(mvm, true);
                    if (mainClass.getName().equals(mvmMainClass)) {
                        return vmPid;
                    }
                } finally {
                    if (mvm != null) {
                        mvm.detach();
                    }
                }
            }
        } catch (java.net.URISyntaxException e) {
            throw new InternalError(e.getMessage());
        } catch (MonitorException e) {
            throw new InternalError(e.getMessage());
        }
        return null;
    }
}

包my.code.a003.process；
导入sun.jvmstat.monitor.HostIdentifier；
导入sun.jvmstat.monitor.monitoreException；
导入sun.jvmstat.monitor.MonitoredHost；
导入sun.jvmstat.monitor.MonitoredVm；
导入sun.jvmstat.monitor.monitoredmutil；
导入sun.jvmstat.monitor.VmIdentifier；
公共类GetOwnPid{
公共静态void main（字符串[]args）{
新建GetOwnPid（）.run（）；
}
公开募捐{
System.out.println（getPid（this.getClass（））；
}
公共整数getPid（类mainClass）{
MonitoredHost MonitoredHost；
设置activeVmPids；
试一试{
monitoredHost=monitoredHost.getMonitoredHost（新主机标识符（（字符串）null））；
activeVmPids=monitoredHost.activeVms（）；
MonitoredVm mvm=null；
用于（整数vmPid:ActiveVMPID）{
试一试{
mvm=monitoredHost.getMonitoredVm（新的VmIdentifier（vmPid.toString（））；
字符串mvmMainClass=monitoredvmultil.mainClass（mvm，true）；
if（mainClass.getName（）.equals（mvmMainClass））{
返回vmPid；
}
}最后{
如果（mvm！=null）{
mvm.detach（）；
}
}
}
}catch（java.net.URISyntaxException e）{
抛出新的内部错误（例如getMessage（））；
}捕获（监视器异常e）{
抛出新的内部错误（例如getMessage（））；
}
返回null；
}
}

几乎没有捕获物：


tool.jar
是一个分布式库
java.lang.management.RuntimeMXBean runtime = 
    java.lang.management.ManagementFactory.getRuntimeMXBean();
java.lang.reflect.Field jvm = runtime.getClass().getDeclaredField("jvm");
jvm.setAccessible(true);
sun.management.VMManagement mgmt =  
    (sun.management.VMManagement) jvm.get(runtime);
java.lang.reflect.Method pid_method =  
    mgmt.getClass().getDeclaredMethod("getProcessId");
pid_method.setAccessible(true);

int pid = (Integer) pid_method.invoke(mgmt);

package my.code.a003.process;

import sun.jvmstat.monitor.HostIdentifier;
import sun.jvmstat.monitor.MonitorException;
import sun.jvmstat.monitor.MonitoredHost;
import sun.jvmstat.monitor.MonitoredVm;
import sun.jvmstat.monitor.MonitoredVmUtil;
import sun.jvmstat.monitor.VmIdentifier;


public class GetOwnPid {

    public static void main(String[] args) {
        new GetOwnPid().run();
    }

    public void run() {
        System.out.println(getPid(this.getClass()));
    }

    public Integer getPid(Class<?> mainClass) {
        MonitoredHost monitoredHost;
        Set<Integer> activeVmPids;
        try {
            monitoredHost = MonitoredHost.getMonitoredHost(new HostIdentifier((String) null));
            activeVmPids = monitoredHost.activeVms();
            MonitoredVm mvm = null;
            for (Integer vmPid : activeVmPids) {
                try {
                    mvm = monitoredHost.getMonitoredVm(new VmIdentifier(vmPid.toString()));
                    String mvmMainClass = MonitoredVmUtil.mainClass(mvm, true);
                    if (mainClass.getName().equals(mvmMainClass)) {
                        return vmPid;
                    }
                } finally {
                    if (mvm != null) {
                        mvm.detach();
                    }
                }
            }
        } catch (java.net.URISyntaxException e) {
            throw new InternalError(e.getMessage());
        } catch (MonitorException e) {
            throw new InternalError(e.getMessage());
        }
        return null;
    }
}

netstat -tupln | grep portNumber

import org.hyperic.sigar.Sigar;

Sigar sigar = new Sigar();
long pid = sigar.getPid();
sigar.close();

public abstract class Process {

    ...

    public long getPid();
}

System.out.println(ProcessHandle.current().pid());

public static boolean isPIDInUse(int pid) {

        try {

            String s = null;
            int java_pid;

            RuntimeMXBean rt = ManagementFactory.getRuntimeMXBean();
            java_pid = Integer.parseInt(rt.getName().substring(0, rt.getName().indexOf("@")));

            if (java_pid == pid) {
                System.out.println("In Use\n");
                return true;
            }
        } catch (Exception e) {
            System.out.println("Exception:  " + e.getMessage());
        }
        return false;
    }

import sys.process._
val pid: Long = Seq("sh", "-c", "echo $PPID").!!.trim.toLong

String jvmName = ManagementFactory.getRuntimeMXBean().getName();
return jvmName.split("@")[0];

int pid = Integer.parseInt(ManagementFactory.getRuntimeMXBean().getName().split("@")[0]);

ApplicationPid pid = new ApplicationPid();
pid.toString();

public static long getPID() {
    String processName = java.lang.management.ManagementFactory.getRuntimeMXBean().getName();
    if (processName != null && processName.length() > 0) {
        try {
            return Long.parseLong(processName.split("@")[0]);
        }
        catch (Exception e) {
            return 0;
        }
    }

    return 0;
}

java.lang.management.ManagementFactory.getRuntimeMXBean().getName().split("@")[0]

final RuntimeMXBean runtime = ManagementFactory.getRuntimeMXBean();
final long pid = runtime.getPid();
out.println("Process ID is '" + pid);

public static void main(String[] args) {
    NodeJS nodeJS = NodeJS.createNodeJS();
    int pid = nodeJS.getRuntime().executeIntegerScript("process.pid;\n");
    System.out.println(pid);
    nodeJS.release();
}