# Java Prozessliste



## jb007 (11. Mai 2007)

Hallo,

ich habe eine Java Applikation die nur einmal gestartet werden darf.
Gibt es eine Möglichkeit die aktuelle Prozessliste aller gestarteten Java Programme abzurufen ?
Das ganze über gesetzte Flags in Property Dateien zu lösen wäre zwar auch möglich aber
ich würde es gerne über eine Prozessliste machen.

Gibt es weiterhin die Möglichkeit die Prozessliste des aktuellen Betriebssystems zu erfragen ?

Vielen Dank schon einmal für alle Antworten.

Gruß Jens


----------



## limago (12. Mai 2007)

Hi, 

ich fürchte, das Du die Processliste nur via Runtime.exec("ps") oder so etwas bekommst. Die Rückgabe kannst Du fangen und auswerten. Das Problem ist, dass die Kommandos OS-abhängig sind. Im Web kursieren viele Lösungen via JNI.


```
package de.tutorials;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		
		try {
			String zeile;
			Process p = Runtime.getRuntime().exec("ps");
			BufferedReader reader = new BufferedReader(new InputStreamReader(p.getInputStream()));
			
			while((zeile = reader.readLine()) != null) {
				System.out.println(zeile);
			}
			
		} catch (IOException e) {
			
			e.printStackTrace();
		}
	}

}
```

Sollte unter Systemen laufen die ein PS Command kennen. Linux, oder wie bei mir Cygwin. Letzteres gibt allerdings nur Cygwin Pids aus.

Ich fürchte, dass macht Dich nicht glücklich, aber vielleicht weiss jemand mehr Rat.


----------



## Thomas Darimont (12. Mai 2007)

Hallo,

das geht ab Java 5 wunderbar mit dem Java Tool JPS:

```
C:\Dokumente und Einstellungen\Tom>jps -q
3532
3240
2904

C:\Dokumente und Einstellungen\Tom>jps -mlvV
3532 Unknown Unknown -Xms40m -Xmx256m
2904 Unknown Unknown -Xms40m -Xmx256m
3976 sun.tools.jps.Jps -mlvV -Denv.class.path=C:\Programme\Java\jre1.6.0\lib\ext\QTJava.zip -Dapplication.home=C:\Programme\Java\jrockit-R27.2.0-jdk1.6.0 -client -Dsun.java.launcher=SUN_STANDARD
```

man kann das natürlich auch mit dem tools.jar machen:

```
/**
 * 
 */
package de.tutorials;

import sun.jvmstat.monitor.MonitoredHost;
import sun.jvmstat.monitor.MonitoredVm;
import sun.jvmstat.monitor.MonitoredVmUtil;
import sun.jvmstat.monitor.VmIdentifier;
import sun.tools.jps.Arguments;

/**
 * @author Tom
 * 
 */
public class JavaProcessListingExample {

    /**
     * @param args
     */
    public static void main(String[] args) throws Exception {

        Arguments arguments = new Arguments(new String[] { "-m", "-mlvV" });

        MonitoredHost monitoredHost = MonitoredHost.getMonitoredHost(arguments
                .hostId());
        for (Object o : monitoredHost.activeVms()) {
            int jvmProcessId = (Integer) o;
            VmIdentifier vmIdentifier = new VmIdentifier("//" + jvmProcessId
                    + "?mode=r");
            MonitoredVm monitoredVm = monitoredHost
                    .getMonitoredVm(vmIdentifier);

            System.out
                    .println("JVM Process ID: " + jvmProcessId
                            + " Main Class: "
                            + MonitoredVmUtil.mainClass(monitoredVm, true)
                            + " Main Args: "
                            + MonitoredVmUtil.mainArgs(monitoredVm)
                            + " JVM Args: "
                            + MonitoredVmUtil.jvmArgs(monitoredVm)
                            + " JVM Flags: "
                            + MonitoredVmUtil.jvmFlags(monitoredVm)
                            + " JVM Version: "
                            + MonitoredVmUtil.vmVersion(monitoredVm));
            monitoredVm.detach();
        }
    }
}
```

Ausgabe:

```
JVM Process ID: 3532 Main Class: Unknown Main Args: Unknown JVM Args: -Xms40m -Xmx256m JVM Flags:  JVM Version: R27.2.0-131-78843-1.6.0-20070320-1457-windows-ia32
JVM Process ID: 2904 Main Class: Unknown Main Args: Unknown JVM Args: -Xms40m -Xmx256m JVM Flags:  JVM Version: R27.2.0-131-78843-1.6.0-20070320-1457-windows-ia32
JVM Process ID: 2688 Main Class: de.tutorials.JavaProcessListingExample Main Args: null JVM Args:  JVM Flags:  JVM Version: 1.6.0-b105
```
Aber das ist ja nur Spielerei... wenn du den Mehrfachstart einer Anwendung verhindern willst kannst du entweder beim erstmaligen Start prüfen ob ein bestimmter Netzwerkport schon belegt ist und wenn nicht dann einfach einen Socket an dem Port horschen lassen. Ist der Port schon belegt ist die Anwendung schon gestartet. Einfach ist's da natürlich mit einem einfachen LockFile zu arbeiten:

```
/**
 * 
 */
package de.tutorials;

import java.io.File;
import java.io.FileOutputStream;
import java.nio.channels.FileLock;
import java.util.concurrent.TimeUnit;

/**
 * @author Thomas.Darimont
 * 
 */
public class LockFileExample {

	/**
	 * @param args
	 */
	public static void main(String[] args) throws Exception {
		File lockFile = new File("c:/tutorials.lock");

		if (!lockFile.exists()) {
			lockFile.createNewFile();
		}

		FileOutputStream fileOutputStream = new FileOutputStream(lockFile);
		FileLock fileLock = fileOutputStream.getChannel().tryLock();

		try {
			if (null != fileLock) {
				System.out.println("Lock acquired");
				TimeUnit.SECONDS.sleep(20L);
				fileLock.release();
			} else {
				System.out.println("Application already running");
			}
		} finally {
			if (null != fileOutputStream) {
				fileOutputStream.close();
			}
		}
	}
}
```

Gruß Tom


----------



## jb007 (14. Mai 2007)

Hallo Jungs,

vielen Dank für die Antworten.
Das wird mich auf jeden Fall weiterbringen.

Noch eine kurze Frage,

kennt Jemand von Euch vielleicht einen guten Browser den man in eine Applikation
integrieren kann ?
Ich meine damit einen reinen Browser ohne History oder einem Suchfeld bei dem der User selber eine Url eingeben kann.

Gruß Jens


----------



## tobias_petry (15. Mai 2007)

in SWT ist direkt einer drinne, ansonsten einfach JDIC (Java Desktop Integration Components) verwenden


----------

