Java'da CPU ve Bellek Kullanımını nasıl kontrol ederim?

Java'da sunucu için CPU ve bellek kullanımını kontrol etmem gerekiyor, bunun nasıl yapılacağını bilen var mı?

Özellikle JVM'de bellek arıyorsanız:

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

Ancak, bunlar sadece bir tahmin olarak alınmalıdır ...

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

Sun JVM kullanıyorsanız ve uygulamanın dahili bellek kullanımıyla ilgileniyorsanız (uygulamanız ayrılan belleğin ne kadarını kullanıyor) JVM'nin yerleşik çöp toplama günlüğünü açmayı tercih ederim. Başlangıç ​​komutuna basitçe -verbose: gc eklersiniz.

Sun belgelerinden:

-Verbose: gc komut satırı argümanı, her koleksiyonda bilgi yazdırır. -Verbose: gc çıktısının biçiminin J2SE platformunun sürümleri arasında değişebileceğini unutmayın. Örneğin, burada büyük bir sunucu uygulamasından çıktı verilmiştir:

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

Burada iki küçük koleksiyon ve bir büyük koleksiyon görüyoruz. Oktan önceki ve sonraki sayılar

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

sırasıyla çöp toplamadan önce ve sonra canlı nesnelerin birleşik boyutunu gösterir. Küçük koleksiyonlardan sonra sayı, canlı olmayan ancak doğrudan canlı oldukları için ya da görevli nesil içinde oldukları veya bunlara referans verildikleri için geri alınamayacak nesneleri içerir. Parantez içindeki sayı

(776768K) (in the first line)

Kalıcı nesildeki alanı saymayan toplam kullanılabilir alandır, toplam yığın eksi hayatta kalan alanlardan biridir. Küçük koleksiyon yaklaşık bir saniyenin dörtte birini aldı.

0.2300771 secs (in the first line)

Daha fazla bilgi için bkz: http://java.sun.com/docs/hotspot/gc5.0/gc_tuning_5.html

Gönderen burada

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

Sağlanan JMX, MXBeans (ThreadMXBean, vb.) Size Bellek ve CPU kullanımları sağlayacaktır.

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

Bellek kullanımı için aşağıdakiler çalışacaktır,

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

CPU kullanımı için, ölçmek için harici bir uygulama kullanmanız gerekecektir.

Java 1.5'ten bu yana, JDK yeni bir araçla birlikte gelir: size herhangi bir 1.5 veya sonraki JVM'nin CPU ve bellek kullanımını gösterebilen JConsole . Bu parametrelerin grafiklerini yapabilir, CSV'ye aktarabilir, yüklenen sınıfların sayısını, örneklerin sayısını, kilitlenmeleri, iş parçacıkları vb. Gösterebilir ...

Burada birçok yanıtta gönderilmiş olan çalışma zamanı / totalMemory çözümünü kullanıyorsanız (bunu çok yaptım), oldukça doğru / tutarlı sonuçlar istiyorsanız önce iki çöp toplamayı zorladığınızdan emin olun.

Verimlilik için Java genellikle çöpün bir GC'yi zorlamadan önce tüm belleği doldurmasına izin verir ve bu durumda bile genellikle tam bir GC değildir, bu nedenle runtime.freeMemory () için sonuçlarınız her zaman "gerçek" boş bellek miktarı ile 0 arasında bir yerde olur .

İlk GC her şeyi almaz, çoğunu alır.

Yükseliş şu ki, sadece freeMemory () çağrısını yaparsanız, kesinlikle yararsız olan ve büyük ölçüde değişen bir numara alacaksınız, ancak 2 gc'yi ilk yaparsanız çok güvenilir bir ölçümdür. Ayrıca rutini ÇOK yavaşlatır (muhtemelen saniyeler).

Java'nın Runtime nesnesi, JVM'nin bellek kullanımını bildirebilir. CPU tüketimi için Unix'in top veya Windows Process Manager gibi harici bir yardımcı program kullanmanız gerekir.

JConsole , çalışan bir Java uygulamasını izlemenin kolay bir yoludur veya uygulamanız hakkında daha ayrıntılı bilgi almak için bir Profiler kullanabilirsiniz. Bunun için NetBeans Profiler'ı kullanmayı seviyorum .

Mevcut bellek kullanımını megabayt cinsinden hesaplamak için bazı basit kodlar:

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

Ayrıca CPU Yükünü izlemek için şu yolu eklerdim:

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

Daha fazlasını buradan okuyabilirsiniz

YourKit Java profilci mükemmel ticari bir çözümdür. Daha fazla bilgiyi CPU profili oluşturma ve bellek profili oluşturma hakkındaki belgelerde bulabilirsiniz .

Tomcat kullanıyorsanız, dahili ve harici bellek tüketiminin yanı sıra diğer birçok alanı da izlemenizi sağlayan Psi Probe'a göz atın .

Eclipse için, bellek kullanımını analiz etmek vb. İçin TPTP'yi (Test ve Performans Araçları Platformu) kullanabilirsiniz. Daha fazla bilgi