जावा से सीपीयू लोड

Question

क्या जेएनआई का उपयोग किए बिना जावा के तहत वर्तमान सीपीयू लोड प्राप्त करने का कोई तरीका है?

Answer 1

का उपयोग OperatingSystemMXBean प्राप्त करने के लिए करें और getSystemLoadAverage() पर कॉल करें।

Answer 2

लिनक्स के तहत आप Runtime का उपयोग कर सकते हैं। "अपटाइम" निष्पादित करने और आउटपुट का मूल्यांकन करने के लिए exec()। मैं लिनक्स के तहत एक बेहतर तरीका नहीं है, और मुझे नहीं लगता कि विंडोज के तहत एक समान "सुविधाजनक" तरीका है।

Answer 3

लिनक्स पर आप केवल फ़ाइल/proc/loadavg पढ़ सकते हैं, जहां पहले तीन मान लोड औसत का प्रतिनिधित्व करते हैं। विंडोज के लिए आपको शायद जेएनआई से चिपकना होगा।

Answer 4

इसमें जेएनआई शामिल है लेकिन Sigar नामक हाइपरिक से एक जीपीएल लाइब्रेरी है जो सभी प्रमुख प्लेटफार्मों के साथ-साथ डिस्क उपयोग जैसे अन्य ओएस-निर्भर आंकड़ों के समूह के लिए यह जानकारी प्रदान करती है। यह हमारे लिए बहुत अच्छा काम करता है।

Answer 5

यदि आप JRockit JVM का उपयोग कर रहे हैं तो आप JMAPI का उपयोग कर सकते हैं। यह जेडीके 1.4, 1.5 और 1.6 के लिए काम करता है।

System.out.println("Total CPU-usage:" + JVMFactory.getJVM().getMachine().getCPULoad()); 

System.out.println("Total JVM-load :" + JVMFactory.getJVM().getJVMLoad()); 

for(Iterator it = JVMFactory.getJVM().getMachine().getCPUs().iterator(); it.hasNext();) 
{ 
    CPU cpu = (CPU)it.next(); 
    System.out.println("CPU Description: " + cpu.getDescription()); 
    System.out.println("CPU Clock Frequency: " + cpu.getClockFrequency()); 
    System.out.println("CPU Load: " + cpu.getLoad()); 
    System.out.println(); 
} 

Answer 6

getSystemLoadAverage() आप समय का मिनट 1 से अधिक मूल्य देता है (हर दूसरे ताज़ा करता है) और समग्र ऑपरेटिंग सिस्टम के लिए यह मान देता है। प्रत्येक थ्रेड को अलग से निगरानी करके अधिक रीयलटाइम अवलोकन किया जाना चाहिए। महत्वपूर्ण निगरानी मॉनिटर रिफ्रेश अंतराल पर भी ध्यान दिया जाता है - अधिकतर बार आप मूल्य की जांच करते हैं, यह अधिक सटीक है कि यह हर पल में है और यदि आप इसे हर मिलीसेकंड करते हैं, तो यह आमतौर पर 0 या 100 (या अधिक CPU के कितने पर निर्भर करता है)। लेकिन अगर हम समय सीमा (उदाहरण के लिए 1 सेकंड) की अनुमति देते हैं, तो हम इस अवधि के दौरान अवतार प्राप्त करते हैं और हमें अधिक जानकारीपूर्ण परिणाम मिलते हैं। साथ ही, यह ध्यान रखना महत्वपूर्ण है कि यह बेहद असंभव है कि केवल एक धागा एक से अधिक CPU (कोर) पर कब्जा कर लेता है। JVM में

getAvarageUsagePerCPU() द्वारा सभी धागे कुल लोड - - सीपीयू प्रति avarage लोड (कोर)

• getTotalUsage():
  कार्यान्वयन के बाद

  3 तरीकों का उपयोग करने की अनुमति देता

• getUsageByThread (थ्रेड टी) - निर्दिष्ट थ्रेड द्वारा कुल भार

  import java.lang.management.ManagementFactory; 
  import java.lang.management.OperatingSystemMXBean; 
  import java.lang.management.ThreadMXBean; 
  import java.util.Collection; 
  import java.util.HashMap; 
  import java.util.HashSet; 
  import java.util.Map; 
  import java.util.Set; 
  
  public class MonitoringThread extends Thread { 
  
      private long refreshInterval; 
      private boolean stopped; 
  
      private Map<Long, ThreadTime> threadTimeMap = new HashMap<Long, ThreadTime>(); 
      private ThreadMXBean threadBean = ManagementFactory.getThreadMXBean(); 
      private OperatingSystemMXBean opBean = ManagementFactory.getOperatingSystemMXBean(); 
  
      public MonitoringThread(long refreshInterval) { 
       this.refreshInterval = refreshInterval; 
  
       setName("MonitoringThread"); 
  
       start(); 
      } 
  
      @Override 
      public void run() { 
       while(!stopped) { 
        Set<Long> mappedIds; 
        synchronized (threadTimeMap) { 
         mappedIds = new HashSet<Long>(threadTimeMap.keySet()); 
        } 
  
        long[] allThreadIds = threadBean.getAllThreadIds(); 
  
        removeDeadThreads(mappedIds, allThreadIds); 
  
        mapNewThreads(allThreadIds); 
  
        Collection<ThreadTime> values; 
        synchronized (threadTimeMap) { 
         values = new HashSet<ThreadTime>(threadTimeMap.values());  
        } 
  
        for (ThreadTime threadTime : values) { 
         synchronized (threadTime) { 
          threadTime.setCurrent(threadBean.getThreadCpuTime(threadTime.getId())); 
         } 
        } 
  
        try { 
         Thread.sleep(refreshInterval); 
        } catch (InterruptedException e) { 
         throw new RuntimeException(e); 
        } 
  
        for (ThreadTime threadTime : values) { 
         synchronized (threadTime) { 
          threadTime.setLast(threadTime.getCurrent());  
         } 
        } 
       } 
      } 
  
      private void mapNewThreads(long[] allThreadIds) { 
       for (long id : allThreadIds) { 
        synchronized (threadTimeMap) { 
         if(!threadTimeMap.containsKey(id)) 
          threadTimeMap.put(id, new ThreadTime(id)); 
        } 
       } 
      } 
  
      private void removeDeadThreads(Set<Long> mappedIds, long[] allThreadIds) { 
       outer: for (long id1 : mappedIds) { 
        for (long id2 : allThreadIds) { 
         if(id1 == id2) 
          continue outer; 
        } 
        synchronized (threadTimeMap) { 
         threadTimeMap.remove(id1); 
        } 
       } 
      } 
  
      public void stopMonitor() { 
       this.stopped = true; 
      } 
  
      public double getTotalUsage() { 
       Collection<ThreadTime> values; 
       synchronized (threadTimeMap) { 
        values = new HashSet<ThreadTime>(threadTimeMap.values());  
       } 
  
       double usage = 0D; 
       for (ThreadTime threadTime : values) { 
        synchronized (threadTime) { 
         usage += (threadTime.getCurrent() - threadTime.getLast())/(refreshInterval * 10000); 
        } 
       } 
       return usage; 
      } 
  
      public double getAvarageUsagePerCPU() { 
       return getTotalUsage()/opBean.getAvailableProcessors(); 
      } 
  
      public double getUsageByThread(Thread t) { 
       ThreadTime info; 
       synchronized (threadTimeMap) { 
        info = threadTimeMap.get(t.getId()); 
       } 
  
       double usage = 0D; 
       if(info != null) { 
        synchronized (info) { 
         usage = (info.getCurrent() - info.getLast())/(refreshInterval * 10000); 
        } 
       } 
       return usage; 
      } 
  
      static class ThreadTime { 
  
       private long id; 
       private long last; 
       private long current; 
  
       public ThreadTime(long id) { 
        this.id = id; 
       } 
  
       public long getId() { 
        return id; 
       } 
  
       public long getLast() { 
        return last; 
       } 
  
       public void setLast(long last) { 
        this.last = last; 
       } 
  
       public long getCurrent() { 
        return current; 
       } 
  
       public void setCurrent(long current) { 
        this.current = current; 
       } 
      } 
  }