Mengoptimumkan penggunaan memori dalam aplikasi Java

Gunakan struktur data yang cekap seperti ArrayList melalui LinkedList dan koleksi primitif untuk mengurangkan overhead; 2. Kurangkan penciptaan objek dengan menggunakan semula objek, menggunakan StringBuilder untuk penggabungan, dan caching objek mahal; 3. Mencegah kebocoran memori dengan membatalkan rujukan, menggunakan kelas dalaman statik, pendengar yang tidak berdaftar, dan menggunakan rujukan lemah/lembut di cache; 4. Tune JVM dengan saiz timbunan yang sesuai, pilih pengumpul sampah yang sesuai (misalnya, G1GC, ZGC), membolehkan pembalakan GC, dan menggunakan alat pemantauan seperti VisualVM atau Prometheus dengan mikrometer; 5. Mengoptimumkan penggunaan rentetan dan array dengan mengelakkan interning yang tidak perlu, berhati -hati dengan substring (), dan pemangkasan saiz array -efisien pengurusan memori dalam Java memerlukan pengekodan pintar, perkakas yang betul, dan kesedaran JVM untuk mengurangkan objek dan meningkatkan prestasi.

Aplikasi Java boleh mengambil lebih banyak ingatan daripada yang diperlukan jika tidak direka dengan teliti, yang membawa kepada isu -isu prestasi, pengumpulan sampah yang lebih lama, dan juga pengecualian OutOfMemoryError . Mengoptimumkan penggunaan memori bukan sekadar peningkatan saiz timbunan -ini mengenai menulis kod yang cekap dan memahami bagaimana JVM menguruskan ingatan. Berikut adalah strategi utama untuk mengurangkan jejak memori dan meningkatkan kecekapan.

1. Gunakan struktur data yang sesuai

Memilih struktur data yang betul boleh memberi kesan kepada penggunaan memori dengan ketara.

• Lebih suka ArrayList Over LinkedList untuk kebanyakan kes penggunaan - LinkedList menyimpan setiap elemen dalam nod dengan rujukan kepada nod seterusnya dan sebelumnya, memakan lebih banyak ingatan.
• Gunakan koleksi primitif jika mungkin. Koleksi Java Standard ( List<integer></integer> , Map<string double></string> ) objek kedai, yang termasuk overhead. Perpustakaan seperti koleksi trove , fastutil , atau gerhana menawarkan koleksi efisien memori untuk primitif (contohnya, TIntArrayList bukannya ArrayList<integer></integer> ).
• Elakkan menyimpan data yang tidak perlu. Sebagai contoh, gunakan Set dan bukan List jika anda hanya memerlukan keunikan dan tidak peduli dengan pesanan.

 // kurang cekap
Senarai <Integer> list = new ArrayList <> ();
list.add (42); // Autoboxing: Membuat objek integer

// lebih cekap (dengan trove)
Senarai TintArrayList = baru TintArrayList ();
list.add (42); // menyimpan int secara langsung

2. Kurangkan penciptaan objek dan penggunaan semula jika mungkin

Setiap objek yang dibuat menambah tekanan kepada pemungut tumpukan dan sampah.

• Gunakan semula objek menggunakan kolam objek untuk contoh yang mahal atau kerap dibuat (misalnya, sambungan pangkalan data, benang-walaupun lebih suka pelaksana terbina dalam).
• Gunakan corak pembina atau flyweight apabila berurusan dengan konfigurasi objek yang sama.
• Elakkan penggabungan rentetan yang tidak perlu dalam gelung -gunakan StringBuilder sebaliknya.

 // Bad: Membuat pelbagai rentetan pertengahan
Hasil rentetan = "";
untuk (rentetan s: rentetan) {
    hasil = s;
}

// baik: pembuat tali tunggal
StringBuilder sb = new StringBuilder ();
untuk (rentetan s: rentetan) {
    sb.Append (s);
}
Hasil rentetan = sb.toString ();

• Cache objek mahal seperti DateFormat , Pattern , atau data konfigurasi dan bukannya mencipta semula.

3. Kawalan Objek Hayat dan Elakkan Kebocoran Memori

Malah objek yang tidak digunakan boleh berlama -lama dalam ingatan jika rujukan tidak sengaja dipegang.

• Membatalkan rujukan dalam objek lama apabila tidak lagi diperlukan (jarang diperlukan dalam java moden tetapi relevan dalam cache atau pendengar).
• Tonton Kebocoran Kelas Dalam : Kelas Batak yang tidak statik memegang rujukan tersirat ke kelas luar. Gunakan kelas dalaman static apabila mungkin.
• Pendengar yang tidak mendaftar (contohnya, peristiwa, corak pemerhati) untuk mencegah pengumpulan.
• Berhati -hati dengan cache -gunakan rujukan lemah/lembut atau cache yang dibatasi (contohnya, Caffeine , Guava Cache ) dan bukannya HashMap biasa.

 // lebih suka rujukan lemah untuk cache
Peta <key, lemahReference <value >> cache = hashmap baru <> ();

• Sumber kebocoran biasa:
  • Koleksi statik yang tumbuh selama -lamanya
  • Aliran atau sumber yang tidak ditutup (gunakan sumber-sumber cuba)
  • Pembolehubah ThreadLocal dalam pelayan aplikasi (terutamanya dengan penyatuan benang)

4. Tune JVM dan memantau penggunaan memori

Bahkan manfaat kod yang ditulis dengan baik dari konfigurasi dan pemantauan JVM yang betul.

• Tetapkan saiz timbunan yang sesuai :

   -XMS512M -XMX2G

  Elakkan menetapkan -Xmx tumpukan besar -besar boleh menyebabkan jeda GC yang panjang.

• Pilih pemungut sampah yang betul :

  • G1GC (Lalai dalam Java 9): Baik untuk timbunan sederhana hingga besar dengan matlamat masa jeda yang rendah.
  • ZGC atau Shenandoah (Java 11 dan 12 masing-masing): Untuk timbunan yang sangat besar dengan masa jeda ultra-rendah (<10ms).

• Aktifkan Pembalakan GC untuk Menganalisis Kelakuan:

   -XLOG: GC*, GC HEAP = DEBUG, GC STATS -XLOG: GC: /VAR/LOG/GC.LOG

• Gunakan alat pemantauan:

  • VisualVM , JConsole , atau JMC (Kawalan Misi Java) untuk analisis masa nyata.
  • Mikrometer Prometheus untuk pemantauan pengeluaran.
  • Dumps Heap ( jmap -dump ) dianalisis dengan tikar Eclipse untuk mencari babi memori.

---

5. Mengoptimumkan penggunaan rentetan dan array

Rentetan dan tatasusunan adalah pengguna memori biasa.

• Elakkan rentetan rentetan melainkan perlu String.intern() menyimpan rentetan dalam permgen/metaspace dan boleh menyebabkan masalah ingatan.
• Gunakan String.substring() dengan teliti dalam versi Java yang lebih lama (pra-Java 7U6): Ia berkongsi array char yang mendasari. Versi moden menyalin data.
• Saiz Array Trim-jangan pra-memperuntukkan tatasusunan besar kecuali diperlukan. Pertimbangkan untuk menggunakan ArrayList dengan pertumbuhan terkawal.

---

Mengoptimumkan memori di Java adalah campuran amalan pengekodan pintar, perkakas yang betul, dan memahami tingkah laku JVM. Fokus pada mengurangkan objek Churn, memilih struktur data yang cekap, menghapuskan kebocoran, dan pemantauan dengan data sebenar. Perubahan kecil boleh menyebabkan peningkatan besar dalam skalabiliti dan respons.

Pada asasnya, ia bukan tentang menulis kurang kod -ini tentang membuat setiap kiraan byte.

Atas ialah kandungan terperinci Mengoptimumkan penggunaan memori dalam aplikasi Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!