मैं Java में CPU और मेमोरी उपयोग की जाँच कैसे करूँ?

Question

मुझे जावा में सर्वर के लिए सीपीयू और मेमोरी उपयोग की जांच करने की आवश्यकता है, किसी को पता है कि यह कैसे किया जा सकता है?

Comments

शायद ये लिंक मददगार होंगे: javaworld.com/javaworld/javaqa/2002-11/01-qa-1108-cpu.html roseindia.net/javatutorials/…

— chessguy

OS-स्तरीय प्रणाली की जानकारी प्राप्त करने के लिए Java

— ग्रेग बेकन

Answer 1

यदि आप विशेष रूप से JVM में मेमोरी के लिए देख रहे हैं:

Runtime runtime = Runtime.getRuntime();

NumberFormat format = NumberFormat.getInstance();

StringBuilder sb = new StringBuilder();
long maxMemory = runtime.maxMemory();
long allocatedMemory = runtime.totalMemory();
long freeMemory = runtime.freeMemory();

sb.append("free memory: " + format.format(freeMemory / 1024) + "<br/>");
sb.append("allocated memory: " + format.format(allocatedMemory / 1024) + "<br/>");
sb.append("max memory: " + format.format(maxMemory / 1024) + "<br/>");
sb.append("total free memory: " + format.format((freeMemory + (maxMemory - allocatedMemory)) / 1024) + "<br/>");

हालाँकि, इन्हें केवल एक अनुमान के रूप में लिया जाना चाहिए ...

Comments

इसलिए यदि मैं ग्रहण में रनरिन हूं, तो यह मेरी ग्रहण सेटिंग्स पर निर्भर करेगा?

— कॉफी

ध्यान दें कि यह वास्तविक उपयोग की गई मेमोरी नहीं है- यह 'आवंटित मेमोरी' है जिसका मतलब है कि ढेर जो जावा ने आवंटित किया है, इसलिए यदि आपके पास -Xms90g है और आपका ऐप बहुत हल्का है, तो आपको अभी भी आवंटित किया जाएगा क्योंकि 90g से अधिक कुछ । नीचे दिए गए "अज्ञात (याहू)" द्वारा उत्तर को देखें (जो कि पहली नज़र में अलग हो सकता है)

— 0fnt

बस जिज्ञासु, ये केवल एक अनुमान क्यों होना चाहिए?

— कंप्यूटर

@ComputerScientist क्योंकि फ्री वास्तव में वह है जो मुफ्त (पोस्ट GC) है, यह GC के लिए प्रतीक्षा कर रही वस्तुओं को नहीं दिखाता है। MUCH को अधिक सटीक बनाने के लिए, इस उत्तर से पहले 2 कचरा संग्रह चलाएं। यदि आप इसे GC के साथ और इसके बिना आज़माते हैं, तो आपको GC-post मान बहुत सुसंगत मिलेंगे, लेकिन प्रीजीसी आम तौर पर कम से कम दोगुनी होगी।

— बिल के

@sbeliakov आप JavaSysmon ( github.com/jezhumble/javasysmon ) का उपयोग कर सकते हैं , हालाँकि मैं आपको एक नया प्रश्न खोलने की सलाह देता हूँ और मैं इसका उत्तर दूंगा। GitHub की लाइब्रेरी में एक बग है और 32 बिट को 64 बिट के रूप में पहचानता है, लेकिन मुझे अलग-अलग जार [ github.com/goxr3plus/XR3Player/blob/master/resources/bibs/… ] को मिलाने का काम मिला ।

— GOXR3PLUS

Answer 2

package mkd.Utils;

import java.io.File;
import java.text.NumberFormat;

public class systemInfo {

    private Runtime runtime = Runtime.getRuntime();

    public String Info() {
        StringBuilder sb = new StringBuilder();
        sb.append(this.OsInfo());
        sb.append(this.MemInfo());
        sb.append(this.DiskInfo());
        return sb.toString();
    }

    public String OSname() {
        return System.getProperty("os.name");
    }

    public String OSversion() {
        return System.getProperty("os.version");
    }

    public String OsArch() {
        return System.getProperty("os.arch");
    }

    public long totalMem() {
        return Runtime.getRuntime().totalMemory();
    }

    public long usedMem() {
        return Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();
    }

    public String MemInfo() {
        NumberFormat format = NumberFormat.getInstance();
        StringBuilder sb = new StringBuilder();
        long maxMemory = runtime.maxMemory();
        long allocatedMemory = runtime.totalMemory();
        long freeMemory = runtime.freeMemory();
        sb.append("Free memory: ");
        sb.append(format.format(freeMemory / 1024));
        sb.append("<br/>");
        sb.append("Allocated memory: ");
        sb.append(format.format(allocatedMemory / 1024));
        sb.append("<br/>");
        sb.append("Max memory: ");
        sb.append(format.format(maxMemory / 1024));
        sb.append("<br/>");
        sb.append("Total free memory: ");
        sb.append(format.format((freeMemory + (maxMemory - allocatedMemory)) / 1024));
        sb.append("<br/>");
        return sb.toString();

    }

    public String OsInfo() {
        StringBuilder sb = new StringBuilder();
        sb.append("OS: ");
        sb.append(this.OSname());
        sb.append("<br/>");
        sb.append("Version: ");
        sb.append(this.OSversion());
        sb.append("<br/>");
        sb.append(": ");
        sb.append(this.OsArch());
        sb.append("<br/>");
        sb.append("Available processors (cores): ");
        sb.append(runtime.availableProcessors());
        sb.append("<br/>");
        return sb.toString();
    }

    public String DiskInfo() {
        /* Get a list of all filesystem roots on this system */
        File[] roots = File.listRoots();
        StringBuilder sb = new StringBuilder();

        /* For each filesystem root, print some info */
        for (File root : roots) {
            sb.append("File system root: ");
            sb.append(root.getAbsolutePath());
            sb.append("<br/>");
            sb.append("Total space (bytes): ");
            sb.append(root.getTotalSpace());
            sb.append("<br/>");
            sb.append("Free space (bytes): ");
            sb.append(root.getFreeSpace());
            sb.append("<br/>");
            sb.append("Usable space (bytes): ");
            sb.append(root.getUsableSpace());
            sb.append("<br/>");
        }
        return sb.toString();
    }
}

Comments

मेरी समझ कि विषय शुरू हुआ ओएस में उपलब्ध स्मृति की मात्रा के बारे में पूछ रहा था। freeMemoryयहाँ जेवीएम में उपलब्ध स्मृति की मात्रा बहुत अलग है

— तगर

क्या यह अजीब नहीं है कि आपका वर्ग SystemInfo किसी कैपिटल और आपके तरीकों से शुरू नहीं होता है Info (), OSname (), MemInfo () करते हैं?

— Drswaki69

Answer 3

यदि आप Sun JVM का उपयोग कर रहे हैं, और एप्लिकेशन की आंतरिक मेमोरी उपयोग में रुचि रखते हैं (आपके ऐप द्वारा कितनी आवंटित मेमोरी का उपयोग किया जा रहा है) तो मैं JVM में निर्मित कचरा संग्रह लॉगिंग चालू करना पसंद करता हूं। आप केवल -verbose: gc को स्टार्टअप कमांड में जोड़ते हैं।

सूर्य प्रलेखन से:

कमांड लाइन तर्क -verbose: gc प्रत्येक संग्रह में जानकारी प्रिंट करता है। ध्यान दें कि -verbose: gc आउटपुट का प्रारूप J2SE प्लेटफ़ॉर्म की रिलीज़ के बीच परिवर्तन के अधीन है। उदाहरण के लिए, यहां एक बड़े सर्वर एप्लिकेशन से आउटपुट है:

[GC 325407K->83000K(776768K), 0.2300771 secs]
[GC 325816K->83372K(776768K), 0.2454258 secs]
[Full GC 267628K->83769K(776768K), 1.8479984 secs]

यहाँ हम दो छोटे संग्रह और एक प्रमुख एक देखते हैं। तीर से पहले और बाद की संख्या

325407K->83000K (in the first line)

क्रमशः कचरा संग्रह से पहले और बाद में जीवित वस्तुओं के संयुक्त आकार को इंगित करें। मामूली संग्रह के बाद गिनती में वे वस्तुएं शामिल हैं जो जरूरी नहीं कि जीवित हों, लेकिन उन्हें पुनः प्राप्त नहीं किया जा सकता है, क्योंकि वे सीधे जीवित हैं, या क्योंकि वे कार्यकाल की पीढ़ी से संदर्भित या संदर्भित हैं। कोष्ठक में संख्या

(776768K) (in the first line)

कुल उपलब्ध स्थान है, जो स्थायी पीढ़ी में स्थान की गिनती नहीं करता है, जो उत्तरजीवी स्थानों में से एक है। मामूली संग्रह में लगभग एक चौथाई सेकंड का समय लगा।

0.2300771 secs (in the first line)

अधिक जानकारी के लिए देखें: http://java.sun.com/docs/hotspot/gc5.0/gc_tunit_@.html

Answer 4

से यहाँ

    OperatingSystemMXBean operatingSystemMXBean = (OperatingSystemMXBean) ManagementFactory.getOperatingSystemMXBean();
    RuntimeMXBean runtimeMXBean = ManagementFactory.getRuntimeMXBean();
    int availableProcessors = operatingSystemMXBean.getAvailableProcessors();
    long prevUpTime = runtimeMXBean.getUptime();
    long prevProcessCpuTime = operatingSystemMXBean.getProcessCpuTime();
    double cpuUsage;
    try
    {
        Thread.sleep(500);
    }
    catch (Exception ignored) { }

    operatingSystemMXBean = (OperatingSystemMXBean) ManagementFactory.getOperatingSystemMXBean();
    long upTime = runtimeMXBean.getUptime();
    long processCpuTime = operatingSystemMXBean.getProcessCpuTime();
    long elapsedCpu = processCpuTime - prevProcessCpuTime;
    long elapsedTime = upTime - prevUpTime;

    cpuUsage = Math.min(99F, elapsedCpu / (elapsedTime * 10000F * availableProcessors));
    System.out.println("Java CPU: " + cpuUsage);

Comments

और मेमोरी के बारे में?

— डैनियल डे लियोन

सूची <MemoryPoolMXBean> memoryPools = new ArrayList <MemoryPoolMXBean> (ManagementFactory.getMemoryPoolMXBeans ()); लंबे समय से इस्तेमाल किया गया for (MemoryPoolMXBean memoryPool: memoryPools) {if (memoryPool.getType ()। बराबर (MemoryType.HEAP)) {MemoryUsage poolCollectionMemoryUsage = memoryPool.getCollectionUsage (); usedHeapMemoryAfterLastGC + = poolCollectionMemoryUsage.getUsed (); }}

— danieln

CPU उपयोग पुनर्प्राप्ति को दिखाने वाले एकमात्र उत्तर के लिए धन्यवाद।

— मैथ्यू

ऐसा करने और बस करने के बीच क्या अंतर है operatingSystemMXBean.getProcessCpuLoad();? ओरेकल प्रलेखन के अनुसार, यह विधि "जावा वर्चुअल मशीन प्रक्रिया के लिए" हाल ही में सीपीयू उपयोग "लौटाती है। फिर भी मुझे आपकी विधि और इस विधि के बीच अपेक्षाकृत बड़ी संख्या में अंतर दिखाई देता है।

— इशांक

@RobHall दो OperatingSystemMXBeanवर्ग हैं। एक इंटरफेस प्रदान किया गया है java.lang। लेकिन एक और संस्करण भी है, जो इस एक को बढ़ाता है com.sun.management। यही वह तरीका है जिसका मैं उल्लेख कर रहा हूंOperatingSystemMXBean

— इशांक

Answer 5

जेएमएक्स, द एमएक्सबीन्स (थ्रेडमेक्सबीन, आदि) आपको मेमोरी और सीपीयू उपयोग प्रदान करेगा।

OperatingSystemMXBean operatingSystemMXBean = (OperatingSystemMXBean) ManagementFactory.getOperatingSystemMXBean();
operatingSystemMXBean.getSystemCpuLoad();

Answer 6

स्मृति उपयोग के लिए, निम्नलिखित काम करेगा,

long total = Runtime.getRuntime().totalMemory();
long used  = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();

CPU उपयोग के लिए, आपको इसे मापने के लिए किसी बाहरी एप्लिकेशन का उपयोग करना होगा।

Answer 7

जावा 1.5 के बाद से JDK एक नया टूल लेकर आया है: JConsole wich आपको 1.5 या बाद के JVM का CPU और मेमोरी उपयोग दिखा सकता है। यह इन मापदंडों के चार्ट कर सकते हैं, CSV को निर्यात कर सकते हैं, भरी हुई कक्षाओं की संख्या दिखा सकते हैं, उदाहरणों की संख्या, गतिरोध, थ्रेड्स आदि ...

Answer 8

यदि आप रनटाइम / TotalMemory समाधान का उपयोग करते हैं जो यहां कई उत्तरों में पोस्ट किया गया है (मैंने ऐसा बहुत किया है), तो दो कचरा संग्रह को पहले मजबूर करना सुनिश्चित करें यदि आप काफी सटीक / सुसंगत परिणाम चाहते हैं।

प्रवाह क्षमता के लिए जावा आमतौर पर GC को मजबूर करने से पहले सभी मेमोरी को भरने की अनुमति देता है, और फिर भी यह आम तौर पर एक पूर्ण GC नहीं है, इसलिए रनटाइम के लिए आपके परिणाम। FreeMemory () हमेशा "मुफ्त" मेमोरी की "वास्तविक" राशि और 0 के बीच कहीं हो। ।

पहले GC को सब कुछ नहीं मिलता है, यह इसे सबसे अधिक मिलता है।

परवरिश यह है कि यदि आप बस फ्रीमोरी () कॉल करते हैं तो आपको एक नंबर मिलेगा जो बिल्कुल बेकार है और व्यापक रूप से भिन्न होता है, लेकिन अगर 2 gc का पहला ऐसा करें तो यह बहुत विश्वसनीय गेज है। यह नियमित MUCH को धीमा बनाता है (सेकंड, संभवतः)।

Answer 9

जावा का रनटाइम ऑब्जेक्ट JVM के मेमोरी उपयोग की रिपोर्ट कर सकता है। सीपीयू की खपत के लिए आपको यूनिक्स के शीर्ष या विंडोज प्रोसेस मैनेजर की तरह एक बाहरी उपयोगिता का उपयोग करना होगा।

Answer 10

मेगाबाइट में वर्तमान मेमोरी उपयोग की गणना करने के लिए यहां कुछ सरल कोड दिए गए हैं:

double currentMemory = ( (double)((double)(Runtime.getRuntime().totalMemory()/1024)/1024))- ((double)((double)(Runtime.getRuntime().freeMemory()/1024)/1024));

Answer 11

मैं सीपीयू लोड को ट्रैक करने के लिए निम्नलिखित तरीके भी जोड़ूंगा:

import java.lang.management.ManagementFactory;
import com.sun.management.OperatingSystemMXBean;

double getCpuLoad() {
    OperatingSystemMXBean osBean =
        (com.sun.management.OperatingSystemMXBean) ManagementFactory.
        getPlatformMXBeans(OperatingSystemMXBean.class);
    return osBean.getProcessCpuLoad();
}

आप यहाँ और पढ़ सकते हैं

Answer 12

JConsole एक चल रहे जावा एप्लिकेशन की निगरानी करने का एक आसान तरीका है या आप अपने आवेदन पर अधिक विस्तृत जानकारी प्राप्त करने के लिए एक प्रोइलर का उपयोग कर सकते हैं। मुझे इसके लिए NetBeans Profiler का उपयोग करना पसंद है ।

Answer 13

YourKit जावा प्रोफाइलर एक उत्कृष्ट वाणिज्यिक समाधान है। आप सीपीयू प्रोफाइलिंग और मेमोरी प्रोफाइलिंग पर डॉक्स में और जानकारी पा सकते हैं ।

Answer 14

यदि आप टॉमकैट का उपयोग कर रहे हैं, तो साई प्रोब की जांच करें , जो आपको आंतरिक और बाहरी मेमोरी खपत के साथ-साथ अन्य क्षेत्रों की मेजबानी की निगरानी करने देता है।

Answer 15

ग्रहण के लिए, आप मेमोरी उपयोग और आदि अधिक जानकारी के विश्लेषण के लिए टीपीटीपी (टेस्ट और परफॉर्मेंस टूल प्लेटफॉर्म) का उपयोग कर सकते हैं