जावा के साथ वर्तमान खुली खिड़कियों / प्रक्रिया की सूची कैसे प्राप्त करें?

Question 1

क्या किसी को पता है कि मुझे जावा का उपयोग करके वर्तमान खुली खिड़कियां या स्थानीय मशीन की प्रक्रिया कैसे मिलती है?

मैं जो करने की कोशिश कर रहा हूं वह यह है: विंडोज टास्कमैनजर की तरह वर्तमान खुले कार्य, विंडोज या प्रक्रिया को खोलें, लेकिन एक बहु-मंच दृष्टिकोण का उपयोग करना - यदि संभव हो तो केवल जावा का उपयोग करना।

Question 2

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

यदि आप Windows का उपयोग कर रहे हैं, तो आपको लाइन बदलनी चाहिए: "प्रोसेस p = Runtime.getRun ..." आदि ... (3rd लाइन), एक के लिए जो इस तरह दिखता है:

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

आशा है कि जानकारी मदद करती है!

Question 3

अंत में, जावा 9+ के साथ यह संभव है 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("-");
}

आउटपुट:

    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

Question 4

विंडोज पर 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);
    }
}

Question 5

जिस तरह से मैं यह करने के बारे में सोच सकता हूं वह एक कमांड लाइन एप्लिकेशन को लागू करने से है जो आपके लिए काम करता है और फिर आउटपुट स्क्रीनस्क्रीनिंग करता है (जैसे लिनक्स का पीएस और विंडो की टास्कलिस्ट)।

दुर्भाग्य से, इसका मतलब है कि आपको दोनों से डेटा पढ़ने के लिए कुछ पार्सिंग दिनचर्या लिखनी होगी।

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

Question 6

YAJSW (फिर भी एक और जावा सेवा आवरण) ऐसा लगता है कि इसमें win32, linux, bsd और Solaris के लिए इसके org.rzo.yajsw.os.TaskList इंटरफ़ेस का JNA- आधारित कार्यान्वयन है और एक LGPL लाइसेंस के तहत है। मैंने इस कोड को सीधे कॉल करने की कोशिश नहीं की है, लेकिन जब मैंने इसे अतीत में उपयोग किया है, तो YAJSW वास्तव में अच्छी तरह से काम करता है, इसलिए आपको बहुत अधिक चिंताएं नहीं होनी चाहिए।

Question 7

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

Question 8

ऐसा करने का कोई प्लेटफ़ॉर्म-न्यूट्रल तरीका नहीं है। जावा के 1.6 रिलीज में, एक " डेस्कटॉप " वर्ग को ब्राउज़ करने, संपादन, मेलिंग, खोलने, और आरआरआई के मुद्रण के पोर्टेबल तरीकों की अनुमति दी गई थी। यह संभव है कि यह वर्ग किसी दिन प्रक्रियाओं का समर्थन करने के लिए बढ़ाया जा सकता है, लेकिन मुझे संदेह है।

यदि आप जावा प्रक्रियाओं में केवल उत्सुक हैं, तो आप JVM पर थ्रेड / मेमोरी जानकारी प्राप्त करने के लिए java.lang.management एपीआई का उपयोग कर सकते हैं ।

Question 9

उन विंडो के लिए जिनका मैं उपयोग कर रहा हूं:

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

Question 10

यह बंडल JRE वाले एप्लिकेशन के लिए उपयोगी हो सकता है: मैं उस फ़ोल्डर के नाम के लिए स्कैन करता हूं जो कि मैं एप्लिकेशन चला रहा हूं: इसलिए यदि आप एप्लिकेशन से निष्पादित कर रहे हैं:

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

तब आप पा सकते हैं कि क्या यह पहले से ही J9 में चल रहा है,

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

Question 11

ps auxलिनक्स के लिए और tasklistखिड़कियों के लिए पार्स के लिए कोड का उपयोग करना आपके सबसे अच्छे विकल्प हैं, जब तक कि कुछ और सामान्य नहीं आता है।

खिड़कियों के लिए, आप संदर्भ दे सकते हैं: http://www.rgagnon.com/javadetails/java-0593.html

लिनक्स के ps auxमाध्यम से grepभी परिणाम पाइप कर सकते हैं, जो प्रसंस्करण / त्वरित और आसान खोज करेगा। मुझे यकीन है कि आप खिड़कियों के लिए भी कुछ ऐसा ही पा सकते हैं।

Question 12

नीचे दिए गए कार्यक्रम केवल जावा 9+ संस्करण के साथ संगत होंगे ...

वर्तमान जानकारी प्राप्त करने के लिए,

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

सभी चल रही प्रक्रियाओं के लिए,

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

Question 13

    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()करना होगा अन्यथा यह लूप में बंद हो जाएगा।

Question 14

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 रनिंग" / एफओ "CSV" / FI "यूजरनेम eq LHPL002 \ सॉफ्ट" / FI "MEMUSAGE gt 10000" / FI "Windowtitle ne N / A" / NH

Question 15

यह एक फ़ंक्शन के लिए मेरा कोड है जो कार्यों को प्राप्त करता है और उनके नाम प्राप्त करता है, उन्हें सूची में शामिल करने के लिए एक सूची में भी जोड़ता है। यह डेटा के साथ अस्थायी फाइलें बनाता है, फाइलों को पढ़ता है और। Exe प्रत्यय के साथ कार्य नाम प्राप्त करता है, और जब सिस्टम System.exit (0) के साथ बाहर निकल जाता है, तो फ़ाइलों को हटाने की व्यवस्था करता है, यह उन प्रक्रियाओं को भी छिपाता है जिनका उपयोग किया जा रहा है कार्य प्राप्त करें और java.exe भी ताकि उपयोगकर्ता गलती से प्रोग्राम को चलाने वाली प्रक्रिया को एक साथ नहीं मार सके।

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