Bagaimana cara memeriksa Penggunaan CPU dan Memori di Java?

Saya perlu memeriksa penggunaan CPU dan memori untuk server di java, ada yang tahu bagaimana itu bisa dilakukan?

Jika Anda mencari memori khusus di 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/>");

Namun, ini harus dianggap hanya sebagai perkiraan ...

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

Jika Anda menggunakan Sun JVM, dan tertarik dengan penggunaan memori internal aplikasi (berapa banyak dari memori yang dialokasikan yang digunakan aplikasi Anda), saya lebih suka mengaktifkan pencatatan pengumpulan sampah bawaan JVM. Anda cukup menambahkan -verbose: gc ke perintah startup.

Dokumentasi Dari Matahari:

Argumen baris perintah -verbose: gc mencetak informasi di setiap koleksi. Perhatikan bahwa format output -verbose: gc dapat berubah sewaktu-waktu di antara rilis platform J2SE. Misalnya, berikut adalah keluaran dari aplikasi server besar:

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

Di sini kita melihat dua koleksi kecil dan satu koleksi besar. Angka-angka sebelum dan sesudah panah

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

menunjukkan ukuran gabungan dari objek aktif sebelum dan sesudah pengumpulan sampah. Setelah koleksi kecil, penghitungan mencakup objek yang belum tentu hidup tetapi tidak dapat diklaim kembali, baik karena benda tersebut hidup secara langsung, atau karena berada di dalam atau dirujuk dari generasi bertenor. Angka dalam tanda kurung

(776768K) (in the first line)

adalah total ruang yang tersedia, tidak termasuk ruang pada generasi permanen, yang merupakan total heap dikurangi satu ruang yang selamat. Pengumpulan kecil membutuhkan waktu sekitar seperempat detik.

0.2300771 secs (in the first line)

Untuk info lebih lanjut lihat: http://java.sun.com/docs/hotspot/gc5.0/gc_tuning_5.html

Dari sini

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

JMX, MXBeans (ThreadMXBean, dll) yang disediakan akan memberi Anda penggunaan Memori dan CPU.

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

Untuk penggunaan memori, berikut ini akan berfungsi,

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

Untuk penggunaan CPU, Anda perlu menggunakan aplikasi eksternal untuk mengukurnya.

Sejak Java 1.5, JDK hadir dengan alat baru: JConsole yang dapat menunjukkan penggunaan CPU dan memori dari JVM 1.5 atau yang lebih baru. Itu dapat melakukan grafik parameter ini, mengekspor ke CSV, menunjukkan jumlah kelas yang dimuat, jumlah instance, kebuntuan, utas, dll ...

Jika Anda menggunakan solusi runtime / totalMemory yang telah diposting di banyak jawaban di sini (saya sudah sering melakukannya), pastikan untuk memaksa dua kumpulan sampah terlebih dahulu jika Anda menginginkan hasil yang cukup akurat / konsisten.

Untuk efisiensi, Java biasanya mengizinkan sampah mengisi semua memori sebelum memaksakan GC, dan bahkan GC biasanya bukan GC lengkap, jadi hasil Anda untuk runtime.freeMemory () selalu berada di antara jumlah "sebenarnya" dari memori bebas dan 0 .

GC pertama tidak mendapatkan segalanya, ia mendapatkan sebagian besar darinya.

Peningkatannya adalah jika Anda hanya melakukan panggilan freeMemory () Anda akan mendapatkan nomor yang sama sekali tidak berguna dan sangat bervariasi, tetapi jika melakukan 2 gc pertama, itu adalah pengukur yang sangat andal. Itu juga membuat JAUH rutin lebih lambat (detik, mungkin).

Objek Runtime Java dapat melaporkan penggunaan memori JVM. Untuk konsumsi CPU, Anda harus menggunakan utilitas eksternal, seperti bagian atas Unix atau Manajer Proses Windows.

JConsole adalah cara mudah untuk memantau aplikasi Java yang sedang berjalan atau Anda dapat menggunakan Profiler untuk mendapatkan informasi lebih rinci tentang aplikasi Anda. Saya suka menggunakan NetBeans Profiler untuk ini.

Berikut beberapa kode sederhana untuk menghitung penggunaan memori saat ini dalam megabyte:

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

Saya juga akan menambahkan cara berikut untuk melacak Beban CPU:

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

Anda dapat membaca lebih lanjut di sini

The YourKit Java profiler adalah solusi komersial yang sangat baik. Anda dapat menemukan informasi lebih lanjut di dokumen tentang profil CPU dan profil memori .

Jika Anda menggunakan Tomcat, lihat Psi Probe , yang memungkinkan Anda memantau konsumsi memori internal dan eksternal serta sejumlah area lainnya.

Untuk Eclipse, Anda dapat menggunakan TPTP (Test and Performance Tools Platform) untuk menganalisis penggunaan memori dan informasi lainnya