¿Cómo obtener una lista de las ventanas/procesos abiertos actuales con Java?

Question

¿Alguien sabe cómo consigo las ventanas abiertas actuales o el proceso de una máquina local usando Java?

Lo que intento hacer es: mostrar la tarea abierta actual, las ventanas o el proceso abierto, como en el Administrador de tareas de Windows, pero utilizando un enfoque multiplataforma, usando solo Java si es posible.

Answer 1

Este es otro enfoque para analizar la lista el proceso desde el comando "ps -e ":

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(); 
} 

Si está usando Windows, entonces usted debe cambiar la línea: "Proceso p = Runtime.getRun ...", etc ... (tercera línea), uno que se parece a esto:

Process p = Runtime.getRuntime().exec 
    (System.getenv("windir") +"\\system32\\"+"tasklist.exe"); 

Esperamos que la información ayuda!

Answer 2

La única forma en que puedo pensar en hacerlo es invocando una aplicación de línea de comandos que hace el trabajo por usted y luego screencraping la salida (como el ps de Linux y la lista de tareas de Windows).

Desafortunadamente, eso significa que tendrá que escribir algunas rutinas de análisis para leer los datos de ambos.

Process proc = Runtime.getRuntime().exec ("tasklist.exe"); 
InputStream procOutput = proc.getInputStream(); 
if (0 == proc.waitFor()) { 
    // TODO scan the procOutput for your data 
} 

Answer 3

No existe una forma neutral de plataforma para hacer esto. En la versión 1.6 de Java, se agregó una clase "Desktop" que permite formas portátiles de explorar, editar, enviar por correo, abrir e imprimir URI. Es posible que esta clase se extienda algún día a procesos de soporte, pero lo dudo.

Si solo tiene curiosidad por los procesos de Java, puede utilizar la api java.lang.management para obtener información sobre el hilo/memoria en la JVM.

Answer 4

YAJSW (Sin embargo, otro servicio de Java Wrapper) parece que tiene implementaciones basadas en JNA de su interfaz org.rzo.yajsw.os.TaskList para Win32, Linux, BSD y Solaris y está bajo una licencia LGPL. No he intentado llamar este código directamente, pero YAJSW funciona muy bien cuando lo he usado en el pasado, por lo que no debería tener demasiadas preocupaciones.

Answer 5

En Windows existe una alternativa usando JNA:

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); 
    } 
} 

Answer 6

El uso de código para analizar ps aux para Linux y para Windows tasklist son sus mejores opciones, hasta que algo más general se presente.

Para las ventanas, puede hacer referencia a: http://www.rgagnon.com/javadetails/java-0593.html

Linux puede canalizar los resultados de ps aux través grep demasiado, lo que haría procesamiento/búsqueda rápida y fácil. Estoy seguro de que puedes encontrar algo similar para Windows también.

Answer 7

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(); 
     } 

    } 
} 

You can create batch file like 

lista de tareas/v/FI "ESTADO eq funcionamiento"/FO "CSV"/FI "nombre de usuario eq LHPL002 \ suave"/FI "10000 gt MEMUSAGE"/FI "WindowTitle ne N/Un"/ NH

Answer 8

Se puede recuperar fácilmente la lista de procesos en ejecución usando jProcesses

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("------------------"); 
} 

Answer 9

Para las ventanas yo uso siguientes:

 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"); 

Answer 10

Por último, con Java 9 es posible con ProcessHandle:

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("-"); 
} 

_{Editar: "será" → "es"}

Answer 11

Misma pregunta (Windows running application list using Java)

Encontré esta respuesta (https://stackoverflow.com/a/2206526) wmic.exe con salida normal by Philippe

try{ 
     Process proc = Runtime.getRuntime().exec("wmic.exe"); 
     BufferedReader input = new BufferedReader(new InputStreamReader(proc.getInputStream())); 
     OutputStreamWriter oStream = new OutputStreamWriter(proc.getOutputStream()); 
     oStream.write("process get caption"); 
     oStream.flush(); 
     oStream.close(); 
     String line; 
     while ((line = input.readLine()) != null){ 
      if(!line.isEmpty() && !line.startsWith("wmic:root\\cli")) { 
       System.out.println(line); 
      } 
     } 
     input.close(); 
}catch (IOException ioe){ioe.printStackTrace();}