Como obter uma lista de janelas/processos abertos no momento com Java?

StackOverflow https://stackoverflow.com/questions/54686

  •  09-06-2019
  •  | 
  •  

Pergunta

Alguém sabe como obtenho as janelas ou processos abertos atuais de uma máquina local usando Java?

O que estou tentando fazer é:liste a tarefa aberta no momento, janelas ou processos abertos, como no Windows Taskmanager, mas usando uma abordagem multiplataforma - usando apenas Java, se for possível.

Foi útil?

Solução

Esta é outra abordagem para analisar a lista de processos do 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();
}

Se você estiver usando Windows, deverá alterar a linha:"Processo p = Runtime.getRun..." etc...(3ª linha), para um que se pareça com isto:

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

Espero que a informação ajude!

Outras dicas

No Windows existe uma 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);
    }
}

Finalmente, com Java 9+ é possível com 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("-");
}

Saída:

    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

A única maneira que consigo pensar em fazer isso é invocando um aplicativo de linha de comando que faz o trabalho para você e, em seguida, capturando a tela da saída (como o ps do Linux e a lista de tarefas do Windows).

Infelizmente, isso significa que você terá que escrever algumas rotinas de análise para ler os dados de ambos.

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

YAJSW (Yet Another Java Service Wrapper) parece ter implementações baseadas em JNA de sua interface org.rzo.yajsw.os.TaskList para win32, linux, bsd e solaris e está sob uma licença LGPL.Não tentei chamar esse código diretamente, mas YAJSW funciona muito bem quando o usei no passado, então você não deve se preocupar muito.

Você pode recuperar facilmente a lista de processos em execução usando jProcessos

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

Não existe uma maneira neutra em termos de plataforma de fazer isso.Na versão 1.6 do Java, um "Área de Trabalho"A classe foi adicionada para permitir formas portáteis de navegação, edição, envio por correio, abertura e impressão de URIs.É possível que algum dia esta classe seja estendida para suportar processos, mas duvido.

Se você está apenas curioso em processos Java, você pode usar o java.lang.management API para obter informações de thread/memória na JVM.

Para Windows eu uso o seguinte:

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

Usando código para analisar ps aux para linux e tasklist para windows são suas melhores opções, até que algo mais geral apareça.

Para Windows, você pode consultar: http://www.rgagnon.com/javadetails/java-0593.html

Linux pode canalizar os resultados de ps aux através grep também, o que tornaria o processamento/pesquisa rápido e fácil.Tenho certeza que você também pode encontrar algo semelhante para Windows.

Isso pode ser útil para aplicativos com um JRE incluído:Procuro o nome da pasta a partir da qual estou executando o aplicativo:então, se seu aplicativo estiver sendo executado de:

 C:\Dev\build\SomeJavaApp\jre-9.0.1\bin\javaw.exe

então você pode descobrir se ele já está rodando no J9, por:

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

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

TASKLIST /v /FI "STATUS eq running" /FO "CSV" /FI "Nome de usuário eq LHPL002\soft" /FI "MEMUSAGE gt 10000" /FI "Título da janela ne N/A" /NH

Este é o meu código para uma função que obtém as tarefas e seus nomes, adicionando-as também em uma lista para serem acessadas a partir de uma lista.Ele cria arquivos temporários com os dados, lê os arquivos e obtém o nome da tarefa com o sufixo .exe, e organiza os arquivos para serem excluídos quando o programa for encerrado com System.exit(0), também oculta os processos que estão sendo usados ​​para obtenha as tarefas e também java.exe para que o usuário não possa encerrar acidentalmente o processo que executa o programa todos juntos.

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();
}
Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top