JavaJVM va xotira9 boʻlim · 26 savol

JVM va xotira: heap, garbage collector va class loading qanday ishlaydi

Bu sahifa JVM qanday ishlashini va Java xotirani qanday boshqarishini chuqur tushuntiradi: kod qanday bajariladi, obyektlar qayerda yashaydi, garbage collector ularni qachon va qanday tozalaydi, productionʼda xotira muammosi qanday topiladi. Murakkab joylar qadamma-qadam animatsiya bilan koʻrsatilgan.

Boʻlimlar asoslardan chuqurroq mavzularga qarab ketadi. Bilgan joyingizni oʻtkazib yuborishingiz yoki istalgan boʻlimdan boshlashingiz mumkin. Hamma narsa HotSpot JVM va Java 21 uchun yozilgan, boshqa LTS versiyalardagi farqlar alohida aytilgan.

Har boʻlim oxirida tushunganingizni tekshiradigan savollar bor. Avval javobni oʻzingiz oʻylab koʻring, keyin oching.

1JDK, JRE va JVM: Java kodi qanday bajariladi

Java dasturi ikki bosqichda ishlaydi. Avval javac kompilyatori .java fayllarni bytecodeʼga aylantiradi — .class fayllardagi, protsessorga bogʻliq boʻlmagan buyruqlarga. Keyin JVM shu bytecodeʼni yuklaydi va bajaradi. Bitta .class fayl Linuxʼda ham, Windowsʼda ham, ARM protsessorda ham ishlaydi: har bir platformaga faqat oʻzining JVMʼi kerak.

NimaTarkibiNima uchun kerak
JVMclass loader, bytecode verifier, interpretator, JIT kompilyatorlar, garbage collectorbytecodeʼni bajarish
JREJVM va standart kutubxona: java.base, java.sql va boshqa modullartayyor dasturni ishga tushirish
JDKJRE va dasturchi vositalari: javac, jar, javap, jcmd, jfr, jlink va boshqalarkod yozish, kompilyatsiya qilish va tahlil qilish

Java 11 dan boshlab Oracle alohida JRE chiqarmaydi: kerak boʻlsa, jlink bilan faqat kerakli modullardan iborat runtime yigʻiladi. Baʼzi distributivlar, masalan Eclipse Temurin, JRE paketini hali ham beradi.

Bytecode — stack asosidagi buyruqlar: iload lokal oʻzgaruvchini operand stack ustiga qoʻyadi, iadd ikkita qiymatni olib, yigʻindisini qaytarib qoʻyadi. Ularni javap -c bilan koʻrish mumkin:

static int add(int a, int b) {
    return a + b;
}

// javap -c Add.class
static int add(int, int);
  Code:
     0: iload_0
     1: iload_1
     2: iadd
     3: ireturn

HotSpot — OpenJDK tarkibidagi JVM — bytecodeʼni avval interpretator bilan bajaradi: buyruqlar birma-bir oʻqiladi va bajariladi. Shu bilan birga JVM statistika yigʻadi: har bir metod necha marta chaqirilgani, sikllar necha marta takrorlangani, qaysi branch bajarilgani va chaqiruvlarga qaysi turlar kelgani. Bu profiling deyiladi. Koʻp ishlaydigan — «issiq» — metodlarni JIT kompilyatori shu profil asosida mashina kodiga aylantiradi va keyingi chaqiruvlar shu kod bilan ketadi.

Shuning uchun Java servisi ishga tushgandan keyin bir muddat sekinroq ishlaydi, keyin tezlashadi. Bu warm-up; JIT va warm-up haqida oxirgi boʻlimda batafsil.

Tushunganingizni tekshiring

JDK, JRE va JVM farqi nima?Javob
Qisqa javob

JVM — bytecodeʼni bajaradigan virtual mashina. JRE — JVM va standart kutubxona, yaʼni tayyor dasturni ishga tushirish uchun kerak boʻlgan hamma narsa. JDK — JRE ustiga dasturchi vositalari: javac, jar, jcmd, jfr va boshqalar.

JVM — spetsifikatsiya va uning implementationʼlari. Spetsifikatsiya bytecode formatini va har bir buyruqning maʼnosini belgilaydi, implementation esa har xil boʻlishi mumkin: eng keng tarqalgani — OpenJDKʼdagi HotSpot, boshqasi — Eclipse OpenJ9. Garbage collector va JIT ham JVMʼning qismi, shuning uchun ularning flagʼlari va xatti-harakati implementationʼga bogʻliq.

Productionʼda dastur JRE yoki jlink bilan yigʻilgan kichik runtimeʼda ishlashi mumkin. Lekin muammoni tahlil qilish uchun JDK vositalari kerak boʻladi: jcmd (heap dump, thread dump, Native Memory Tracking), jfr, jstack. Shuning uchun baʼzi jamoalar konteyner imageʼida toʻliq JDK qoldiradi.

Java interpretatsiya qilinadigan tilmi yoki kompilyatsiya qilinadigan?Javob
Qisqa javob

Ikkalasi ham. javac manba kodni bytecodeʼga kompilyatsiya qiladi. JVM bytecodeʼni avval interpretator bilan bajaradi, koʻp ishlaydigan metodlarni esa dastur ishlab turganda JIT kompilyatori mashina kodiga aylantiradi.

Interpretator darhol ishlay boshlaydi, lekin har bir buyruqni alohida bajargani uchun sekin. JIT kompilyatsiyasi vaqt va CPU talab qiladi, shuning uchun JVM uni hamma kodga emas, faqat issiq metodlarga qoʻllaydi: odatda dastur vaqtining katta qismi kodning kichik qismida oʻtadi.

JIT oddiy kompilyatordan bir narsada ustun: u dastur qanday ishlayotganini koʻrib turadi. Masalan, interfeys metodi chaqiriladigan joyga amalda doim bitta klass kelayotgan boʻlsa, JIT shu klassning metodini chaqiruv joyiga koʻchirib qoʻyadi — bu inlining deyiladi. Bu taxmin keyin buzilsa, kompilyatsiya qilingan kod bekor qilinadi va bajarilish interpretatorga qaytadi — bu deoptimization.

HotSpotʼda ikkita JIT kompilyatori bor: C1 tez kompilyatsiya qiladi, C2 sekinroq, lekin ancha optimallashgan kod beradi. Ular birgalikda tiered compilation sxemasida ishlaydi.

2Stack va heap: nima qayerda saqlanadi

Har bir threadʼning oʻz stackʼi bor. Metod chaqirilganda stack ustiga yangi frame qoʻyiladi: unda metodning parametrlari, lokal oʻzgaruvchilari va hisoblash uchun operand stack turadi. Metod tugashi bilan frame olib tashlanadi — buning uchun GC kerak emas.

Obyektlar va massivlar esa heapʼda yaratiladi. Heap bitta va hamma threadʼlar uchun umumiy. Lokal oʻzgaruvchida obyektning oʻzi emas, unga reference turadi. Primitiv lokal oʻzgaruvchi (int, long, double) esa qiymatning oʻzini saqlaydi.

1/6Thread ishga tushdi: stackʼda main() metodining frameʼi paydo boʻldi. Unda shu metodning lokal oʻzgaruvchilari turadi. Heap hozircha boʻsh.
NimaQayerda
primitiv lokal oʻzgaruvchi, metod parametrithreadʼning stackʼidagi frameʼda
obyekt turidagi lokal oʻzgaruvchiframeʼda faqat reference; obyektning oʻzi — heapʼda
obyekt va uning fieldʼlari, hatto int fieldʼlar hamheapʼda, obyektning ichida
massivlar, Stringʼlar va string poolheapʼda
static fieldʼlarheapʼda, klassning Class obyektida (HotSpot)
klass metamaʼlumotlari: metodlar bytecodeʼi, constant poolMetaspaceʼda — heapʼdan tashqarida

Bitta istisno bor: JIT escape analysis yordamida obyekt metoddan tashqariga chiqmasligini isbotlasa, uni umuman yaratmasligi mumkin — obyekt fieldʼlari oddiy lokal qiymatlarga aylanadi. Bu faqat optimizatsiya, dastur natijasi oʻzgarmaydi.

Stack oʻlchami cheklangan: u -Xss bilan beriladi, default — platformaga qarab 1–2 MB (Linux x64 da 1 MB). Rekursiya juda chuqurlashsa, yangi frame uchun joy qolmaydi va StackOverflowError tashlanadi.

Tushunganingizni tekshiring

Stack va heap farqi nima? Nima qayerda saqlanadi?Javob
Qisqa javob

Stack — har bir threadʼning oʻziniki: unda metod chaqiruvlarining frameʼlari, ularda parametrlar va lokal oʻzgaruvchilar turadi. Heap — hamma threadʼlar uchun umumiy: obyektlar va massivlar shu yerda yaratiladi va ularni garbage collector tozalaydi.

Lokal oʻzgaruvchi primitiv boʻlsa, frameʼda qiymatning oʻzi turadi. Obyekt turidagi lokal oʻzgaruvchida esa faqat reference turadi, obyekt — heapʼda. Obyektning fieldʼlari, hatto int boʻlsa ham, obyekt bilan birga heapʼda boʻladi.

Stack xotirasi juda arzon: frame metod chaqirilganda qoʻyiladi va metod tugashi bilan olib tashlanadi. Heapʼdagi obyekt esa uni yaratgan metod tugagandan keyin ham yashashi mumkin — unga reference qolgan boʻlsa. Uni qachon oʻchirish mumkinligini garbage collector hal qiladi.

Stack bitta threadʼga tegishli, shuning uchun lokal oʻzgaruvchilarni boshqa thread koʻrmaydi. Heapʼdagi obyektga esa bir nechta thread murojaat qilishi mumkin — synchronization masalasi aynan shu yerdan boshlanadi.

StackOverflowError nima sababdan chiqadi va uni qanday tuzatasiz?Javob
Qisqa javob

Threadʼning stackʼida yangi frame uchun joy qolmaganda. Deyarli har doim sabab — toʻxtamaydigan yoki juda chuqur rekursiya. Tuzatish — toʻxtash shartini tekshirish yoki rekursiyani sikl bilan qayta yozish; -Xssni kattalashtirish faqat chuqurlik chegaralangan va oldindan maʼlum boʻlganda yordam beradi.

Har bir chaqiruv frame qoʻshadi, frame oʻlchami esa parametrlar va lokal oʻzgaruvchilar soniga bogʻliq. Default stackʼda kichik metod oʻzini oʻn minglab marta chaqira oladi, katta frameʼli metod esa ancha kam.

Rekursiya har doim koʻzga tashlanmaydi. Koʻp uchraydigan tuzoq — ikki tomonlama bogʻlangan entityʼlar: Order.toString() Customerni chiqaradi, Customer.toString() esa yana Orderlarni. equals va hashCode ham shunday aylanib qolishi mumkin; Lombokʼning @ToString va @EqualsAndHashCode annotatsiyalari bunday klasslarda aynan shu xatoga olib keladi.

StackOverflowError — Error, uni ushlab, ishni davom ettirish tavsiya qilinmaydi: stack qayerda uzilgani nomaʼlum, obyektlar chala holatda qolgan boʻlishi mumkin. -Xss hamma threadʼlarga taʼsir qiladi; chuqur rekursiya faqat bitta vazifada kerak boʻlsa, new Thread(group, task, name, stackSize) bilan alohida thread yaratish mumkin.

long factorial(int n) {
    // toʻxtash sharti yoʻq
    return n * factorial(n - 1);
}

long factorialLoop(int n) {
    long r = 1;
    for (int i = 2; i <= n; i++) r *= i;
    return r;
}

3Garbage collector: qaysi obyekt tirik

C va C++ da xotirani dasturchi oʻzi boʻshatadi (free, delete). Bu uch xil xatoga olib keladi: dangling pointer — boʻshatilgan xotiraga yana murojaat qilish, double free — bitta xotirani ikki marta boʻshatish va memory leak — boʻshatishni unutish. Birinchi ikkitasi dasturni kutilmagan joyda buzadi yoki xavfsizlik teshigi ochadi.

Javaʼda free yoʻq. Obyektni qachon oʻchirish mumkinligini garbage collector oʻzi aniqlaydi va bunda reachability mezoni ishlatiladi: GC roots deb ataladigan boshlangʻich nuqtalardan referenceʼlar zanjiri boʻylab yetib boriladigan obyekt tirik, yetib boʻlmaydigani — garbage.

GC roots — dastur hozir bevosita ishlatayotgan referenceʼlar: ishlayotgan threadʼlar stackʼidagi lokal oʻzgaruvchilar va parametrlar, yuklangan klasslarning static fieldʼlari, JNI orqali native kod saqlagan referenceʼlar va synchronized bilan band qilingan obyektlar.

1/6Heapʼda oltita obyekt va ular orasidagi referenceʼlar. GC roots — threadʼlar stackʼidagi lokal oʻzgaruvchilar va static fieldʼlar. Pastda — shu obyektlar xotirada qanday joylashgani.

GC ishining eng qimmat qismi — tirik obyektlarni topish va koʻchirish. Garbage bilan GC deyarli ishlamaydi: copying collectorʼlar, masalan young generationʼda, tirik obyektlarni boshqa joyga koʻchiradi va eski hududni butunligicha boʻsh deb belgilaydi. Shuning uchun bitta GCʼning narxi garbage miqdoriga deyarli bogʻliq emas, tirik obyektlar soniga bogʻliq. Lekin garbage tez yaratilsa, GC tez-tez boʻladi.

Bu ishda obyektlar koʻchadi va ularga referenceʼlar yangilanadi. Ilova shu paytda obyektlar grafini oʻzgartirib tursa, GC adashadi, shuning uchun baʼzi bosqichlarda ilova threadʼlari toʻxtatiladi — bu stop-the-world pauza. Zamonaviy collectorʼlar ishning koʻp qismini concurrent, yaʼni ilovani toʻxtatmasdan bajaradi — bu haqda GC algoritmlari boʻlimida.

System.gc() GCʼni majburlamaydi — bu faqat iltimos. G1, Parallel va Serial collectorʼlarida u butun heap boʻyicha stop-the-world full GC boshlaydi, -XX:+DisableExplicitGC bilan esa umuman eʼtiborsiz qoldiriladi. GC qachon kerakligini JVM heap holatiga qarab oʻzi yaxshiroq biladi.

Tushunganingizni tekshiring

Garbage collector qanday muammoni hal qiladi? Uning narxi nima?Javob
Qisqa javob

Xotirani qoʻlda boshqarishdagi xatolarni yoʻqotadi: dangling pointer, double free va boʻshatishni unutish. Obyekt yetib boʻlmaydigan boʻlganda GC uni oʻzi tozalaydi. Narxi — GC ishlatadigan CPU, qoʻshimcha xotira va pauzalar.

Javaʼda boʻshatilgan xotiraga murojaat qilib boʻlmaydi: obyektga reference bor ekan, u tirik, reference yoʻqolgandan keyingina GC uni oʻchiradi. Bu xatolarning butun bir turini yoʻq qiladi va API dizaynini soddalashtiradi: «bu obyektni kim boʻshatadi?» degan savol yoʻq.

Narxi ham bor. GC CPU vaqtini oladi, samarali ishlashi uchun heap tirik maʼlumotdan bir necha baravar katta boʻlishi kerak, ilova esa vaqti-vaqti bilan pauza qiladi. Qaysi narx muhimroq ekaniga qarab collector tanlanadi.

GC memory leakʼdan toʻliq himoya qilmaydi. U faqat yetib boʻlmaydigan obyektlarni oʻchiradi: endi kerak boʻlmasa ham reference saqlanib qolgan obyekt — masalan, hech qachon tozalanmaydigan static Mapdagi entry — tirik hisoblanadi.

Obyekt qachon garbage collection uchun tayyor boʻladi?Javob
Qisqa javob

GC rootsʼdan unga referenceʼlar zanjiri qolmaganda: hech bir tirik threadʼning lokal oʻzgaruvchisi, static field yoki boshqa tirik obyekt unga yetib bormaydi. Bir-biriga reference saqlaydigan, lekin rootʼlardan uzilgan obyektlar ham tayyor.

Odatda bu oʻz-oʻzidan boʻladi: metod tugadi va lokal oʻzgaruvchi yoʻqoldi, kolleksiyadan element oʻchirildi, fieldʼga boshqa obyekt berildi. Reachability zanjir boʻylab tekshiriladi: a → b → c boʻlsa, aga reference yoʻqolishi bilan uchalasi ham garbage.

«Tayyor» degani «darhol oʻchiriladi» degani emas. Obyekt keyingi GCʼda, old generationʼda boʻlsa — ancha keyin oʻchirilishi mumkin. GC qachon boʻlishi kafolatlanmaydi, shuning uchun fayl, socket yoki connection kabi resurslar GCʼga ishonib emas, try-with-resources bilan yopiladi.

JIT lokal oʻzgaruvchi oxirgi marta qayerda ishlatilganini biladi: metod hali tugamagan boʻlsa ham, keyin ishlatilmaydigan oʻzgaruvchi obyektni tirik ushlab turmasligi mumkin. Shuning uchun lokal oʻzgaruvchiga null yozish deyarli hech qachon kerak emas. Uzoq yashaydigan obyektning fieldʼlarida esa kerak: masalan, ArrayList.remove elementlarni surgandan keyin boʻshagan oxirgi katakka null yozadi, aks holda massiv keraksiz obyektni ushlab turardi.

class Node { Node next; }

void demo() {
    Node a = new Node();
    Node b = new Node();
    a.next = b;
    b.next = a;  // cycle
    a = null;
    b = null;
    // ikkala Node ham GC uchun tayyor:
    // rootʼlardan ularga yoʻl yoʻq
}
GC tirik obyektlarni qanday topadi? Mark, sweep va compaction nima?Javob
Qisqa javob

Mark bosqichida GC rootsʼdan boshlab referenceʼlar boʻylab yuriladi va yetib borilgan har bir obyekt tirik deb belgilanadi. Sweep belgilanmagan obyektlar joyini boʻshatadi. Compaction tirik obyektlarni bir tomonga suradi, shunda boʻsh joy bir butun boʻladi.

Mark — graf boʻylab yurish: rootʼlardan boshlab har bir obyektning reference fieldʼlari koʻrib chiqiladi. Ish hajmi tirik obyektlar soniga bogʻliq, garbage soniga emas.

Faqat sweep qilinsa, xotira teshiklarga boʻlinib qoladi: jami boʻsh joy yetarli, lekin katta massiv uchun bir butun joy yoʻq. Compaction buni hal qiladi, lekin obyektlarni koʻchirish va ularga hamma referenceʼlarni yangilash kerak. Buning foydasi ham bor: compactionʼdan keyin yangi obyekt uchun joy ajratish pointerʼni obyekt oʻlchamicha surishdan iborat.

Young generationʼda copying ishlatiladi: tirik obyektlar boshqa hududga koʻchiriladi, eski hudud esa butunligicha boʻsh boʻladi. Bu mark va compactionʼni bitta oʻtishda bajaradi va tirik obyekt kam boʻlganda juda tez.

4Heap tuzilishi: young va old generation, oʻlcham

Koʻp dasturlarda obyektlarning aksariyati yaratilganidan keyin tez orada keraksiz boʻlib qoladi: soʻrov uchun yaratilgan DTO, String, iterator va lambdaʼlar bir necha millisekundda garbage boʻladi. Uzoq yashaydiganlari esa — cache, connection pool, Spring beanʼlari — odatda dastur oxirigacha yashaydi. Bu generational gipoteza, HotSpot collectorʼlari shunga qurilgan: heap young va old generationʼga boʻlinadi.

Serial va Parallel collectorʼlarida young generation uch qismdan iborat: Eden va ikkita survivor, S0 va S1. G1 da survivor — regionlar toʻplami: tirik obyektlar boʻsh regionlarga koʻchiriladi, doim boʻsh turadigan ikkinchi survivor yoʻq. Yangi obyektlar Edenʼda yaratiladi: har bir thread Edenʼdan oʻziga TLAB deb ataladigan kichik boʻlak oladi va unda lockʼsiz, pointerʼni surish orqali joy ajratadi. Eden toʻlganda minor GC boshlanadi.

1/8Serial va Parallel collectorʼlaridagi young generation: Eden va ikkita survivor (G1 da survivor — regionlar toʻplami). Yangi obyektlar Edenʼda yaratiladi; Eden toʻldi — minor GC boshlanadi. Misolda yosh chegarasi 2, default MaxTenuringThreshold — 15.
HududNima saqlaydiQachon tozalanadi
Edenyangi yaratilgan obyektlarhar minor GCʼda: tiriklari survivorʼga koʻchadi, Eden butunlay boʻshaydi
Survivorbir necha minor GCʼdan omon qolganlar; Serial va Parallel da — S0 va S1, ikkisidan biri doim boʻshhar minor GCʼda: tiriklari boʻsh survivor joyiga yoki old generationʼga koʻchadi
Old generationuzoq yashaydigan obyektlarmajor yoki full GCʼda; G1 da — mixed GC bilan qisman

Minor GC faqat young generationʼni tozalaydi, lekin old generationʼdagi obyektlardan young obyektlarga referenceʼlar ham root hisoblanadi. Ularni topish uchun old generation toʻliq koʻrib chiqilmaydi: old generationʼning qaysi joyiga young obyektga reference yozilganini JVM card table orqali belgilab boradi. G1 bundan tashqari har bir region uchun remembered set yuritadi.

Heap oʻlchamini ikki flag beradi: -Xms — boshlangʻich, -Xmx — maksimal. Ular berilmasa, JVM oʻlchamni mashina xotirasidan hisoblaydi: maksimal heap — fizik xotiraning 1/4 qismi (MaxRAMPercentage=25), boshlangʻich — 1/64 qismi. Konteynerda fizik xotira oʻrniga konteyner limiti olinadi. Juda kichik xotirada, bir necha yuz MB atrofida, ulush kattaroq boʻladi.

# heap 2 GB, boshidan toʻliq
java -Xms2g -Xmx2g -jar app.jar

# JVM tanlagan oʻlchamlarni koʻrish
java -XX:+PrintFlagsFinal -version \
  | grep -E 'InitialHeapSize|MaxHeapSize'

Heap toʻlganda JVM avval GC qiladi. Undan keyin ham yangi obyekt uchun joy topilmasa va heap -Xmxgacha kattalashib boʻlgan boʻlsa, obyekt yaratmoqchi boʻlgan threadʼda OutOfMemoryError: Java heap space tashlanadi.

Tushunganingizni tekshiring

Young generation qanday ishlaydi? Obyekt old generationʼga qachon oʻtadi?Javob
Qisqa javob

Yangi obyektlar Edenʼda yaratiladi. Eden toʻlganda minor GC tirik obyektlarni boʻsh survivorʼga koʻchiradi va yoshini bittaga oshiradi, Eden esa butunlay boʻshaydi. Yoshi chegaraga (default 15) yetgan yoki survivorʼga sigʻmagan obyekt old generationʼga koʻchiriladi — bu promotion.

Serial va Parallel collectorʼlarida ikki survivor navbat bilan ishlaydi: har GCʼda biri «from», ikkinchisi «to». Eden va «from»dagi tirik obyektlar «to»ga koʻchiriladi, keyin ular rol almashadi, shuning uchun survivorʼlardan biri doim boʻsh turadi. G1 da survivor — regionlar toʻplami: tirik obyektlar boʻsh regionlarga koʻchiriladi, doim boʻsh turadigan ikkinchi survivor yoʻq.

Minor GC narxi tirik obyektlar soniga bogʻliq, Eden oʻlchamiga emas: garbage bilan GC umuman ishlamaydi. Obyektlarning koʻpi tez keraksiz boʻlsa — generational gipoteza oʻrinli boʻlsa — minor GC tez va arzon.

Chegara -XX:MaxTenuringThreshold bilan beriladi: default 15, undan katta boʻlishi mumkin emas, chunki yosh obyekt headerʼida 4 bitda saqlanadi. JVM chegarani dinamik ham kamaytiradi: survivor toʻlib qolsa, obyektlar ertaroq old generationʼga oʻtadi. Bu premature promotion: oʻrtacha muddat yashaydigan obyektlar old generationʼni toʻldiradi va qimmatroq GCʼlar koʻpayadi.

-Xms va -Xmx nimani belgilaydi? Ular berilmasa, heap qancha boʻladi?Javob
Qisqa javob

-Xmx — heapʼning maksimal oʻlchami, -Xms — boshlangʻich oʻlchami. Ular berilmasa, maksimal heap fizik xotiraning (konteynerda — limitning) 1/4 qismi, boshlangʻich — 1/64 qismi boʻladi.

Heap -Xmsdan boshlab kerak boʻlganda -Xmxgacha kattalashadi va GC uni yana kichraytirishi mumkin. Har bir kattalashish va kichrayish — qoʻshimcha ish. Shuning uchun serverlarda koʻpincha -Xms va -Xmx teng qilinadi: JVM butun xotirani boshidan oladi va oʻlcham oʻzgarmaydi.

Oʻlcham tirik maʼlumot hajmidan kelib chiqib tanlanadi: full GCʼdan keyin heapʼda qancha qoladi. Heap undan bir necha baravar katta boʻlishi kerak, aks holda GC tez-tez ishlaydi. Juda katta heap ham bepul emas: xotira ortiqcha ketadi, Parallel kabi collectorʼlarda esa full GC pauzasi uzayadi. Toʻgʻri oʻlchamni real yuklama ostidagi GC logi koʻrsatadi.

Default 25% server uchun koʻpincha kam: 4 GB konteynerda heap atigi 1 GB boʻladi. Konteynerda heap odatda -XX:MaxRAMPercentage bilan foizda beriladi — bu haqda konteyner boʻlimida.

Heap toʻlsa nima boʻladi?Javob
Qisqa javob

Avval GC ishga tushadi. Undan keyin ham joy yetmasa va heap -Xmxga yetib boʻlgan boʻlsa, obyekt yaratmoqchi boʻlgan threadʼda OutOfMemoryError: Java heap space tashlanadi. Undan oldin odatda bir necha full GC boʻladi va ilova keskin sekinlashadi.

Jarayon bosqichma-bosqich: Eden toʻlsa — minor GC; old generation toʻlib borsa — concurrent sikl yoki major GC; bular ham yetmasa — butun heap boʻyicha full GC. Har bir keyingi bosqich qimmatroq, shuning uchun heap toʻlishga yaqinlashganda ilova OOMʼdan ancha oldin sekinlasha boshlaydi.

OutOfMemoryError — Error, uni ushlash mumkin, lekin keyin ishni davom ettirish xavfli: xato istalgan threadʼda, istalgan qatorda chiqishi mumkin va obyektlar chala holatda qoladi. Productionʼda odatda heap dump olinadi va jarayon qayta ishga tushiriladi: -XX:+HeapDumpOnOutOfMemoryError va -XX:+ExitOnOutOfMemoryError.

Yana bir himoya bor: GC vaqtning 98% dan koʻpini olsa-yu, heapʼning 2% dan kamini boʻshatsa, OutOfMemoryError: GC overhead limit exceeded tashlanadi. Bu ilova deyarli faqat GC bilan band boʻlib, uzoq «osilib» qolmasligi uchun. Bu tekshiruv uzoq vaqt faqat Parallel GCʼda edi; JDK 26 dan, keyin Java 21 va 25 ning yangi updateʼlarida G1 da ham bor.

5GC algoritmlari va GC logi

Collector tanlash uch narsa orasidagi kompromiss. Throughput — CPU vaqtining qancha qismi ilovaga, qanchasi GCʼga ketadi. Latency — pauzalar qancha davom etadi. Footprint — GC uchun qancha qoʻshimcha xotira kerak. Bittasini yaxshilash odatda boshqasini yomonlashtiradi.

CollectorQanday ishlaydiQachon tanlanadi
Serialbitta threadʼda, hamma ish stop-the-worldkichik heap, bitta CPU
Parallelkoʻp threadʼda, lekin hamma ish stop-the-worldbatch ishlar, maksimal throughput; Java 8 da default
G1heap regionlarga boʻlingan, marking concurrent, obyektlarni koʻchirish pauzadaJava 9 dan default; pauza va throughput muvozanati
ZGCdeyarli hamma ish concurrent, obyektlarni koʻchirish hampauzalar odatda 1 ms dan qisqa va heap oʻlchamiga bogʻliq emas
ShenandoahZGC kabi concurrent compactionpast latency; Oracle JDK buildʼlarida yoʻq

G1 heapʼni bir xil oʻlchamdagi regionlarga boʻladi, odatda 1–32 MB. Young va old generation — regionlar toʻplami, ular xotirada ketma-ket turishi shart emas. G1 old generationʼni concurrent marking bilan tahlil qiladi va keyin garbage eng koʻp boʻlgan regionlarni birinchi tozalaydi — nomi shundan: Garbage First. Pauza maqsadi -XX:MaxGCPauseMillis bilan beriladi (default 200 ms), G1 har pauzada nechta regionni olishni shunga moslaydi. Bu maqsad, kafolat emas.

ZGC obyektlarni ilova ishlab turganda koʻchiradi: har bir reference oʻqilganda kichik tekshiruv — load barrier — obyekt koʻchgan-koʻchmaganini aniqlaydi. Pauzalar heap 10 GB boʻladimi yoki 1 TB, deyarli bir xil. ZGC Java 15 dan production uchun tayyor; Java 21 da generational rejim qoʻshildi (-XX:+ZGenerational), Java 23 da u default boʻldi, Java 24 da eski rejim olib tashlandi.

# collector tanlash
-XX:+UseParallelGC
-XX:+UseG1GC -XX:MaxGCPauseMillis=100

# Java 21: generational ZGC
-XX:+UseZGC -XX:+ZGenerational
# Java 23+: generational rejim default
-XX:+UseZGC

GC qanday ishlayotganini log koʻrsatadi. Java 9 dan beri hamma JVM loglari bitta -Xlog flagi bilan yoqiladi (Java 8 da — -XX:+PrintGCDetails va -Xloggc). Productionʼda GC logi faylga yoziladi, fayllar soni va oʻlchami cheklanadi:

# qisqa: har GC uchun bitta qator
java -Xlog:gc -jar app.jar

# batafsil, faylga: 5 ta fayl, har biri 20 MB gacha
java \
  '-Xlog:gc*:file=gc.log:time,uptime:filecount=5,filesize=20M' \
  -jar app.jar

G1 ning -Xlog:gc qatori shunday koʻrinadi:

[12.345s][info][gc] GC(41) Pause Young (Normal) (G1 Evacuation Pause) 612M->148M(1024M) 6.712ms
QismMaʼnosi
[12.345s]JVM ishga tushganidan beri oʻtgan vaqt
GC(41)GCʼning tartib raqami
Pause Young (Normal)young GC pauzasi; boshqalari — Pause Young (Mixed), Pause Full
(G1 Evacuation Pause)sabab: Eden toʻldi
612M->148M(1024M)GCʼdan oldin va keyin band heap; qavs ichida — committed heap, yaʼni JVM OSʼdan olgan xotira
6.712mspauza davomiyligi

Logdan uch narsa olinadi. Pauzalar: ularning davomiyligi va tez-tezligi, ayniqsa Pause Full. Allocation rate: ilova sekundiga qancha xotira ajratadi. Old generation trendi: GCʼdan keyin qolgan hajm — -> dan keyingi son — vaqt oʻtishi bilan oʻsib borsa, bu leak yoki heap kichikligining belgisi.

Tushunganingizni tekshiring

Stop-the-world pauza nima va u nega kerak?Javob
Qisqa javob

GC baʼzi ishlarni bajarayotganda hamma ilova threadʼlari toʻxtatiladi — bu stop-the-world pauza. Sabab: GC obyektlarni koʻchiradi va referenceʼlarni yangilaydi; ilova shu paytda obyektlar grafini oʻzgartirsa, GC tirik obyektni oʻtkazib yuborishi yoki eski manzilni qoldirishi mumkin.

Threadʼlar istalgan joyda emas, safepointʼda toʻxtaydi: bu kodda JVM har bir reference qayerda turganini aniq biladigan nuqta. Pauza ikki qismdan iborat: hamma threadʼlar safepointʼga yetib kelguncha ketgan vaqt — time to safepoint — va GCʼning oʻz ishi. Safepoint GCʼdan tashqari boshqa JVM amallari uchun ham ishlatiladi, masalan thread dump va deoptimizationʼning baʼzi turlari uchun.

Concurrent collectorʼlar ishning koʻp qismini ilova bilan bir vaqtda bajaradi. Buning uchun ular ilova kodiga barrierʼlar qoʻshadi: reference yozilganda yoki oʻqilganda GC bundan xabar topadi. G1 da marking concurrent, lekin obyektlarni koʻchirish hali pauzada. ZGC va Shenandoah koʻchirishni ham concurrent qiladi, shuning uchun ularning pauzalari juda qisqa.

Pauza foydalanuvchiga latency orqali taʼsir qiladi: soʻrovlarning oʻrtacha vaqti yaxshi boʻlsa ham, GC pauzasiga toʻgʻri kelgan soʻrovlar p99 va p999 ni oshiradi.

Parallel, G1 va ZGC farqi nima? Qaysi birini qachon tanlaysiz?Javob
Qisqa javob

Parallel GC maksimal throughput beradi, lekin hamma ishni stop-the-world bajaradi — katta heapʼda pauzalar uzun. G1 — muvozanat: heap regionlarga boʻlingan, pauza maqsadi bor (default 200 ms). ZGC deyarli hamma ishni concurrent bajaradi: pauzalar millisekunddan qisqa, lekin CPU va xotira koʻproq ketadi.

Parallel — batch ishlar, hisob-kitoblar va pauza muhim boʻlmagan joylar uchun: GCʼga eng kam CPU ketadi. G1 — koʻp servislar uchun yaxshi default: oʻrta va katta heapʼda oldindan aytsa boʻladigan pauzalar. ZGC — latency qatʼiy boʻlgan servislar va juda katta heap uchun: pauza heap oʻlchamiga bogʻliq emas.

ZGC narxi — barrierʼlar tufayli biroz kamroq throughput va zaxira xotira: GC concurrent ishlayotganda ilova ham obyekt yaratishda davom etadi va bunga joy kerak. Allokatsiya juda tez boʻlsa va zaxira yetmasa, ilova threadʼlari GC tugashini kutib qoladi — logda bu Allocation Stall deb koʻrinadi.

Tanlashdan oldin oʻlchang: oʻsha yuklama, oʻsha heap oʻlchami bilan GC logi va p99 latencyʼni solishtiring. Koʻp hollarda collectorʼni almashtirishdan koʻra allokatsiyani kamaytirish yoki heap oʻlchamini toʻgʻrilash koʻproq foyda beradi.

GC logidan nimalarni oʻqiysiz? Allocation rateʼni qanday hisoblaysiz?Javob
Qisqa javob

Har bir pauzaning turi, sababi va davomiyligi, GCʼdan oldin va keyin band heap hajmi. Allocation rate — ketma-ket ikki young GC orasida heap qanchaga oʻsgani, shu vaqt oraligʻiga boʻlingan. GCʼdan keyin qolgan hajm vaqt oʻtishi bilan oʻsib borsa — leak yoki heap kichikligining belgisi.

Pastdagi misolda 10,0 s dagi GC heapʼni 150 MB gacha tozaladi, 12,0 s dagi keyingi GC oldidan heap 1150 MB. Demak 2 sekundda 1000 MB ajratilgan — allocation rate taxminan 500 MB/s. Allocation rate qancha yuqori boʻlsa, young GC shuncha tez-tez boʻladi.

Old generation qanchalik tez oʻsishi — promotion rate — ham shunday kuzatiladi: har young GCʼdan keyin old generation qanchaga oʻsdi. U yuqori boʻlsa, old generation tez toʻladi va qimmat GCʼlar koʻpayadi.

Qoʻlda hisoblash shart emas: GCeasy, GCViewer kabi vositalar logdan grafik va statistika chiqaradi, JFR yozuvida esa GC maʼlumotlari tayyor. Ishlab turgan jarayonni tez koʻrish uchun jstat -gcutil <pid> 1000 har sekundda hududlar qanchalik toʻlganini koʻrsatadi.

[10.000s][info][gc] GC(41) Pause Young (Normal) (G1 Evacuation Pause) 612M->150M(2048M) 6.712ms
[12.000s][info][gc] GC(42) Pause Young (Normal) (G1 Evacuation Pause) 1150M->160M(2048M) 7.105ms

6Klasslar: yuklash, initsializatsiya va ClassLoader

JVM klassni dastur boshida emas, birinchi kerak boʻlganda yuklaydi. Bu uch bosqichda boʻladi. Loading: class loader .class faylni topadi va oʻqiydi, JVM klass metamaʼlumotlarini Metaspaceʼga yozadi va heapʼda uning Class obyektini yaratadi. Linking: bytecode toʻgʻriligi tekshiriladi, static fieldʼlar default qiymat oladi (0, null, false), boshqa klasslarga belgili havolalar esa odatda kerak boʻlganda haqiqiy manzillarga aylantiriladi. Initialization: static field initsializatorlari va static bloklar manbadagi tartibda bajariladi.

Initialization klass bilan birinchi haqiqiy ishda boʻladi: obyekt yaratilganda, static metod chaqirilganda, static fieldʼga murojaat qilinganda yoki Class.forName(name) chaqirilganda. Bola klassdan oldin ota klass initsializatsiya qilinadi. Static blok har bir klass uchun bir marta bajariladi va JVM buni thread-safe qiladi: ikki thread bir vaqtda kelsa, ikkinchisi birinchisi tugashini kutadi.

Initsializatsiyani boshlamaydigan holatlar ham bor: compile-time konstantaga murojaat (javac uning qiymatini chaqiruv joyiga koʻchirib qoʻyadi), Foo.class literal, new Foo[10] massiv yaratish, ota klassning static fieldʼiga bola klass nomi orqali murojaat — bunda faqat ota initsializatsiya qilinadi.

class Parent {
    static { System.out.println("1 Parent static"); }
    { System.out.println("3 Parent block"); }
    Parent() { System.out.println("4 Parent()"); }
}
class Child extends Parent {
    static { System.out.println("2 Child static"); }
    { System.out.println("5 Child block"); }
    Child() { System.out.println("6 Child()"); }
}

new Child(); // 1 2 3 4 5 6
// static bloklar qayta ishlamaydi:
new Child(); // 3 4 5 6

Klasslarni class loaderʼlar yuklaydi va ular ierarxiya tashkil qiladi. Bootstrap loader JVMʼning oʻziga qurilgan va asosiy modullarni, masalan java.baseni yuklaydi; Java kodida u null boʻlib koʻrinadi. Platform loader (Java 9 dan; Java 8 da uning oʻrnida Extension loader edi) boshqa JDK modullarini, masalan java.sqlni yuklaydi. Application loader classpath va module pathʼdagi ilova klasslarini yuklaydi.

1/7Kod com.app.User klassiga birinchi marta murojaat qildi. Soʻrov Application loaderʼga keladi: u avval allaqachon yuklangan klasslar orasidan qidiradi — yoʻq.

Bu parent delegation: loader klassni oʻzi qidirishdan oldin otasidan soʻraydi, ota esa oʻz otasidan. Shuning uchun JDK klasslarini classpathʼga soxta versiya qoʻyib almashtirib boʻlmaydi. Java 9 dan loader avval paket qaysi modulga tegishli ekanini tekshiradi va modul maʼlum boʻlsa, soʻrovni toʻgʻridan-toʻgʻri oʻsha modul loaderʼiga beradi; classpathʼdagi klasslar uchun esa eski tartib — avval ota — ishlaydi.

Klass metamaʼlumotlari — metodlar bytecodeʼi, constant pool, fieldʼlar va metodlar tavsifi — Metaspaceʼda saqlanadi. Java 8 da u PermGen oʻrnini egalladi: PermGen heapʼning qatʼiy oʻlchamli qismi edi, Metaspace esa native xotirada va default holatda cheklanmagan, limit -XX:MaxMetaspaceSize bilan qoʻyiladi. Klass faqat uni yuklagan loader butunlay yetib boʻlmaydigan boʻlganda unload qilinadi, shuning uchun bitta qolib ketgan reference loaderʼni hamma klasslari bilan birga xotirada ushlab turadi — bu ClassLoader leak.

Tushunganingizni tekshiring

Klass qachon yuklanadi va static blok qachon bajariladi?Javob
Qisqa javob

Klass birinchi kerak boʻlganda yuklanadi. static blok initialization bosqichida bajariladi: birinchi new, static metod chaqiruvi yoki static fieldʼga murojaat paytida. U har bir klass uchun bir marta va thread-safe ishlaydi.

Yuklash va initsializatsiya bir narsa emas. ClassLoader.loadClass klassni yuklaydi, lekin initsializatsiya qilmaydi; Class.forName(name) esa default holatda initsializatsiya ham qiladi. Foo.class literal, new Foo[10] yoki compile-time konstantaga murojaat static blokni ishga tushirmaydi.

Compile-time konstanta — primitiv yoki String turidagi, konstanta ifoda bilan berilgan static final field. javac uning qiymatini ishlatilgan joyga koʻchirib qoʻyadi, shuning uchun klassga murojaat umuman boʻlmaydi. static final Integer yoki static final int X = compute() esa konstanta emas — ularga murojaat initsializatsiyani boshlaydi.

JVM initsializatsiyani lock ostida bajaradi: ikki thread bir vaqtda kelsa, biri static blokni bajaradi, ikkinchisi kutadi. Lazy singleton uchun holder idiomi shunga tayanadi: synchronizedsiz, xavfsiz va obyekt faqat birinchi murojaatda yaratiladi.

class Config {
    static final int LIMIT = 10;     // konstanta
    static final Integer BOXED = 10; // konstanta emas
    static { System.out.println("init"); }
}

int a = Config.LIMIT;     // "init" chiqmaydi
Integer b = Config.BOXED; // "init" chiqadi
Ota va bola klassda static bloklar, instance bloklar va konstruktorlar qaysi tartibda bajariladi?Javob
Qisqa javob

Avval static qism: ota klassning static fieldʼlari va bloklari, keyin bolaniki — faqat birinchi marta. Keyin har bir newda: ota klassning instance fieldʼlari va bloklari, ota konstruktori, keyin bolaning instance fieldʼlari va bloklari, bola konstruktori.

Har bir klass ichida field initsializatorlari va bloklar manbadagi tartibda bajariladi: static int a = 1; va undan keyingi static { } yozilgan ketma-ketlikda. Instance qism ham shunday: u konstruktordagi super(...) chaqiruvidan keyin, konstruktor tanasidan oldin bajariladi.

Bola konstruktori birinchi boʻlib super(...)ni chaqiradi, shuning uchun avval ota toʻliq quriladi, keyin bolaning fieldʼlari qiymat oladi. Bundan klassik tuzoq chiqadi: ota konstruktori override qilingan metodni chaqirsa, bu metod bolaning hali qiymat olmagan fieldʼlarini koʻradi — null yoki 0.

class Base {
    Base() { hello(); }
    void hello() {}
}
class User extends Base {
    String name = "Ali";
    @Override void hello() {
        System.out.println(name);
    }
}

new User(); // null — name hali qiymat olmagan
Parent delegation qanday ishlaydi va u nima uchun kerak?Javob
Qisqa javob

Class loader klassni yuklashdan oldin soʻrovni ota loaderʼga beradi, u esa oʻz otasiga — Bootstrap loaderʼgacha. Yuqoridagilar topmasagina pastdagi loader klassni oʻzi qidiradi. Bu JDK klasslarini almashtirib boʻlmasligini va bitta klass bir marta yuklanishini taʼminlaydi.

ClassLoader.loadClass avval allaqachon yuklangan klasslar orasidan qidiradi (findLoadedClass), keyin otasidan soʻraydi va faqat oxirida oʻzi qidiradi (findClass). Natijada java.lang.Objectni hamma loader bir xil koʻradi: uni doim Bootstrap yuklaydi.

Klassning identifikatori — nomi va uni yuklagan loader. Bir xil .class faylni ikki loader yuklasa, JVM uchun bu ikki xil klass: ClassCastException: class com.app.User cannot be cast to class com.app.User (com.app.User is in unnamed module of loader … @…; com.app.User is in unnamed module of loader … @…) aynan shunday chiqadi. Tomcat kabi serverlar har bir ilovaga alohida loader beradi va ilova klasslarini avval oʻzidan qidiradi — bu parent delegationʼdan ataylab chetga chiqish.

Klass unload qilinishi uchun uni yuklagan loader, uning hamma klasslari va ularning obyektlari yetib boʻlmaydigan boʻlishi kerak. Redeploydan keyin eski ilovaning bitta obyektiga reference qolsa — umumiy thread poolʼdagi ThreadLocalda, JDBC driverʼning DriverManagerdagi roʻyxatida yoki ilova toʻxtatmagan threadʼda — eski loader hamma klasslari bilan Metaspaceʼda qoladi. Bir necha redeployʼdan keyin — OutOfMemoryError: Metaspace.

7Memory leak, heap dump va reference turlari

Javaʼda memory leak — endi kerak boʻlmagan, lekin hali ham yetib boriladigan obyektlar. GC ularni oʻchira olmaydi, chunki rootʼlardan ularga yoʻl bor. Leak sekin rivojlanadi: har full GCʼdan keyin qolgan hajm oʻsib boradi, GC tez-tez va uzoqroq ishlaydi va oxiri OutOfMemoryError: Java heap space keladi.

Koʻp uchraydigan sabablar: hech qachon tozalanmaydigan static Map yoki cache; qoʻshilgan, lekin olib tashlanmagan listenerʼlar; thread poolʼdagi threadʼlarda remove() qilinmagan ThreadLocal; tashqi obyektga yashirin reference saqlaydigan non-static ichki klass yoki lambda uzoq yashaydigan joyda; HashMapga qoʻyilgandan keyin hashCodei oʻzgargan kalit; yopilmagan resurslar.

class SessionRegistry {
    // har yangi session qoʻshiladi, lekin hech
    // qachon oʻchirilmaydi — heap sekin toʻladi
    static final Map<String, Session> SESSIONS =
            new ConcurrentHashMap<>();

    static void onLogin(Session s) {
        SESSIONS.put(s.id(), s);
    }
}

Leakni heap dump topadi — heapʼdagi hamma obyektlar va ular orasidagi referenceʼlarning surati. U jcmd bilan olinadi yoki OOM paytida avtomatik yoziladi va Eclipse MAT, VisualVM yoki IntelliJ IDEA profilerʼida ochiladi.

# ishlab turgan jarayondan (oldin full GC qilinadi)
jcmd <pid> GC.heap_dump /dumps/app.hprof

# OOM paytida avtomatik
-XX:+HeapDumpOnOutOfMemoryError
-XX:HeapDumpPath=/dumps

Baʼzan leakʼning oldini olish uchun referenceʼning oʻzini kuchsizroq qilish kerak boʻladi. Oddiy reference — strong: u bor ekan, obyekt tirik. java.lang.ref paketida yana uch tur bor, ular GCʼga obyektni ushlab turmaslikka ruxsat beradi:

ReferenceGC qachon tozalaydiNima uchun
strong — oddiy referencehech qachon, reference bor ekanhamma odatiy kod
SoftReferencexotira yetishmaganda yoki uzoq vaqt ishlatilmaganda (HotSpot LRU qoidasi, -XX:SoftRefLRUPolicyMSPerMB); OutOfMemoryErrordan oldin albattaxotiraga qarab qisqaradigan cache (kamdan-kam toʻgʻri tanlov)
WeakReferencestrong reference qolmagach, obyekt turgan hududni tozalaydigan birinchi GCʼda (old generationʼdagi obyekt uchun bu young GC emas)obyektga qoʻshimcha maʼlumot bogʻlash, WeakHashMap
PhantomReferenceobyekt yetib boʻlmaydigan boʻlgach; get() doim nullobyekt yoʻqolgandan keyin resursni tozalash, Cleaner

Obyekt oʻchirilishidan oldin biror ish bajarishning eski usuli — finalize() — Java 9 da deprecated qilingan, Java 18 da esa olib tashlash uchun belgilangan (JEP 421). Resurslar try-with-resources bilan yopiladi, zaxira tozalash uchun esa Java 9 dagi Cleaner ishlatiladi.

Tushunganingizni tekshiring

Garbage collector bor tilda memory leak qanday paydo boʻladi?Javob
Qisqa javob

Obyekt endi kerak emas, lekin unga reference qolgan: GC uchun u tirik. Koʻpincha bu tozalanmaydigan static kolleksiya yoki cache, olib tashlanmagan listener yoki ThreadLocal, yoki uzoq yashaydigan obyektdagi ortiqcha reference.

Klassik misol — static Mapga qoʻshib, hech qachon oʻchirmaslik: har bir session, soʻrov yoki foydalanuvchi uchun entry qolib ketadi. Oʻlchami va muddati cheklanmagan cache ham leakʼning oʻzi. Uni oddiy HashMap bilan emas, limit va TTL beradigan kutubxona — masalan Caffeine — bilan qilish kerak.

ThreadLocal thread poolʼda xavfli: thread tugamaydi, shuning uchun unga yozilgan qiymat ham yoʻqolmaydi. Soʻrov oxirida remove() qilinmasa, qiymat keyingi soʻrovga oʻtib ketadi va xotirada qoladi. Ichki klass, anonymous klass yoki lambda tashqi obyektning field yoki metodini ishlatsa, unga reference saqlaydi: ular uzoq yashaydigan joyga — listenerʼlar roʻyxatiga yoki schedulerʼga — berilsa, tashqi obyekt ham ular bilan birga yashaydi.

Belgilari: har full GCʼdan keyin old generation yuqoriroq darajada qoladi, full GC tez-tez boʻladi, oxiri OOM. Bu heap kichikligiga oʻxshaydi; farqi trendda: leakʼda tirik maʼlumot hajmi yuklama oʻzgarmasa ham oʻsib boradi.

Heap dumpʼni qanday olasiz va unda leakʼni qanday topasiz?Javob
Qisqa javob

jcmd <pid> GC.heap_dump file.hprof bilan yoki OOM paytida -XX:+HeapDumpOnOutOfMemoryError orqali. Dump Eclipse MAT kabi vositada ochiladi: dominator tree eng koʻp xotira ushlab turgan obyektlarni koʻrsatadi, path to GC roots esa ularni kim tirik ushlab turganini.

Ikki oʻlchov bor. Shallow size — obyektning oʻzi egallagan joy. Retained size — shu obyekt oʻchsa, u bilan birga boʻshaydigan butun xotira, yaʼni faqat u orqali yetib boriladigan obyektlar. Leak qidirganda retained size muhim: 48 baytlik HashMap obyekti 2 GB ni ushlab turgan boʻlishi mumkin.

Odatiy yoʻl: dominator treeʼda eng katta obyektni topish, keyin uning path to GC rootsʼini ochish — zanjir oxirida koʻpincha static field, thread yoki ThreadLocal turadi. Bir necha soat farq bilan olingan ikki dumpʼni solishtirish ham yordam beradi: qaysi klass obyektlari soni oʻsib boryapti. Tezkor tekshiruv uchun jcmd <pid> GC.class_histogram dumpʼsiz, klasslar boʻyicha obyektlar sonini beradi.

Ehtiyot boʻlish kerak: dump olish ilovani toʻxtatadi, heap katta boʻlsa — soniyalar yoki daqiqalarga. Fayl band heap hajmicha boʻladi va unda heapʼdagi hamma narsa bor — parollar, tokenlar, foydalanuvchilarning shaxsiy maʼlumotlari. Uni xavfsiz joyda saqlash va ishi bitgach oʻchirish kerak.

Strong, soft va weak reference farqi nima? WeakHashMap qachon kerak?Javob
Qisqa javob

Strong reference obyektni GCʼdan himoya qiladi. SoftReferencedagi obyektni GC xotira yetishmaganda, shuningdek uzoq vaqt ishlatilmagan boʻlsa tozalaydi, OutOfMemoryErrordan oldin esa albatta. WeakReferencedagi obyekt strong reference qolmagach, u turgan hududni tozalaydigan birinchi GCʼda yoʻqoladi. WeakHashMap kalitlarni weak ushlaydi: kalitga boshqa joyda reference qolmasa, entry oʻzi oʻchadi.

WeakHashMap obyektga qoʻshimcha maʼlumot bogʻlash uchun kerak: obyektning hayotini siz boshqarmaysiz, lekin u yashayotgan paytda unga nimadir biriktirish kerak. Masalan, klass yoki class loader boʻyicha metamaʼlumot: loader yoʻqolsa, entry ham yoʻqoladi va leak boʻlmaydi.

Tuzoqlari bor. Qiymat oʻz kalitiga strong reference saqlasa, entry hech qachon oʻchmaydi. String literal kalitlar ham oʻchmaydi — ular string poolʼda yashaydi. Kalitlar equals bilan solishtiriladi, shuning uchun mazmunan teng boshqa obyekt ham entryʼni topadi. WeakHashMap thread-safe emas.

SoftReference asosidagi cache oddiy koʻrinadi, lekin amalda yaxshi ishlamaydi: GC uni qachon tozalashini bashorat qilib boʻlmaydi, xotira toʻlganda esa birdaniga koʻp entry yoʻqoladi va heap toʻla holatda GC koʻp ishlaydi. Oʻlchami cheklangan cache — masalan, Caffeine maximumSize bilan — odatda yaxshiroq tanlov.

Map<Object, String> meta = new WeakHashMap<>();
Object key = new Object();
meta.put(key, "data");

key = null; // kalitga strong reference qolmadi
// GC obyektni tozalagach, entry oʻchadi
// va meta.size() 0 boʻladi

8Konteynerdagi JVM va heapʼdan tashqari xotira

Konteynerda xotira va CPU limiti cgroup orqali beriladi va JVM uni oʻqiydi: Java 10 dan (Java 8 da — 8u191 dan) -XX:+UseContainerSupport default yoqilgan. Shuning uchun default heap mashina xotirasidan emas, konteyner limitidan hisoblanadi, CPU soni ham limitdan olinadi. Yangi Linux distributivlaridagi cgroup v2ʼni JVM Java 15, 11.0.16 va 8u372 dan boshlab tushunadi: undan eski build limitni koʻrmaydi va butun mashina xotirasidan hisoblaydi.

Konteynerda heap odatda foizda beriladi: -XX:MaxRAMPercentage=75 — limitning 75 foizi. Bitta image turli limitlar bilan ishlaganda bu qulay: limit oʻzgarsa, heap ham oʻzgaradi. -Xmx berilsa, foiz eʼtiborsiz qoladi.

# limit 2 GB → heap ≈ 1,5 GB
java -XX:MaxRAMPercentage=75 -jar app.jar

# JVM koʻrgan limit (faqat Linux)
java -XshowSettings:system -version
# hisoblangan heap
java -XX:MaxRAMPercentage=75 -XshowSettings:vm -version

Limit heapʼga emas, butun jarayonga qoʻyiladi, JVM esa heapʼdan tashqari ham koʻp xotira ishlatadi:

QismNimaNima bilan cheklanadi
Metaspaceklass metamaʼlumotlari-XX:MaxMetaspaceSize, default cheklanmagan
Code cacheJIT kompilyatsiya qilgan mashina kodi-XX:ReservedCodeCacheSize, default 240 MB
Thread stackʼlarhar bir platform threadʼning stackʼi-Xss × threadʼlar soni
GC maʼlumotlaricard table, remembered set, marking bitmapʼlarcollector va heap oʻlchamiga bogʻliq
Direct bufferʼlarByteBuffer.allocateDirect, NIO va Netty bufferʼlari-XX:MaxDirectMemorySize, default — maksimal heap oʻlchami
Boshqa native xotiraJNI kutubxonalar, java.util.zip, malloc arenaʼlariJVM cheklamaydi

Shuning uchun -Xmx limitga teng boʻlsa, jarayon ertami-kechmi limitdan oshadi. Odatiy boshlangʻich nuqta — heap uchun limitning 50–75 foizi, qolgani native xotira uchun; aniq ulushni ilovaning oʻzida oʻlchash kerak.

Native xotirani Native Memory Tracking, qisqasi NMT, koʻrsatadi. U JVM ishga tushayotganda yoqiladi va keyin jcmd orqali soʻraladi:

java -XX:NativeMemoryTracking=summary -jar app.jar

jcmd <pid> VM.native_memory summary
# vaqt oʻtishi bilan nima oʻsganini koʻrish
jcmd <pid> VM.native_memory baseline
jcmd <pid> VM.native_memory summary.diff

NMT faqat JVM oʻzi ajratgan xotirani koʻradi. Jarayonning haqiqatda band qilgan fizik xotirasi — RSS — NMT jamisidan ancha katta boʻlsa, farq JVMʼdan tashqarida: native kutubxonalar yoki malloc fragmentatsiyasi. Glibcʼli Linuxʼda koʻp threadʼli ilova malloc arenaʼlari tufayli ortiqcha xotira olishi mumkin, buni MALLOC_ARENA_MAX muhit oʻzgaruvchisi cheklaydi.

Tushunganingizni tekshiring

JVM konteyner limitini qanday koʻradi? Konteynerda heap oʻlchamini qanday berasiz?Javob
Qisqa javob

JVM cgroupʼdan xotira va CPU limitini oʻqiydi (Java 10+, 8u191+) va default heapʼni limitdan hisoblaydi — 25%. Odatda heap -XX:MaxRAMPercentage bilan, masalan 75%, beriladi va qolgan joy native xotira uchun qoldiriladi.

Default 25% konteyner uchun kam: 2 GB limitda heap atigi 512 MB, qolgan 1,5 GB koʻpincha ishlatilmay turadi. Boshqa tomondan, limitning 100% ini heapʼga berish ham xato: Metaspace, thread stackʼlar, code cache va direct bufferʼlar uchun joy qolmaydi.

Eski build xavfli: Java 15, 11.0.16 va 8u372 dan oldingi versiyalar cgroup v2ʼni tushunmaydi va heapʼni hostning butun xotirasidan hisoblaydi — 64 GB nodeʼdagi 1 GB konteynerda heap 16 GB boʻlib qoladi va jarayon tezda oʻldiriladi. JVM nimani koʻrayotganini java -XshowSettings:system -version koʻrsatadi.

CPU limiti ham muhim: undan GC va JIT threadʼlari soni, ForkJoinPool.commonPool() parallelizmi hisoblanadi. Java 21 va 25 da JVM 1 ta CPU yoki taxminan 1792 MB dan kam xotira koʻrsa, G1 oʻrniga Serial GCʼni tanlaydi. Kerak boʻlsa, collector aniq beriladi yoki -XX:ActiveProcessorCount bilan CPU soni koʻrsatiladi.

OOMKilled va OutOfMemoryError farqi nima?Javob
Qisqa javob

OutOfMemoryError — JVM ichidagi xato: heap, Metaspace yoki boshqa hudud oʻz limitiga yetdi, JVM exception tashlaydi va jarayon ishlashda davom etishi mumkin. OOMKilled — jarayon butun konteyner limitidan oshdi va Linux kernel uni SIGKILL bilan oʻldirdi: exception ham, stack trace ham, heap dump ham boʻlmaydi.

Kubernetesʼda OOMKilled pod holatida koʻrinadi, jarayon esa 137 kod bilan tugaydi: 128 + 9, yaʼni SIGKILL. Ilova logida hech narsa boʻlmaydi — u shunchaki yoʻqoladi.

OOMKilled odatda heap toʻlgani uchun emas: heap -Xmx bilan cheklangan, undan oshsa OutOfMemoryError chiqqan boʻlardi. Sabab — heap va native xotiraning yigʻindisi: heap limitga juda yaqin berilgan, threadʼlar koʻpaygan, direct bufferʼlar yoki native kutubxona xotirasi oʻsgan. Tashxis: NMT bilan native xotirani oʻlchash va konteyner xotirasi grafigini heap grafigi bilan solishtirish.

Tuzatish: heapʼni kamaytirish (masalan, MaxRAMPercentageni 75 dan 60 ga) yoki limitni oshirish, keyin oʻsayotgan native qismni topish — threadʼlar soni, MaxDirectMemorySize, MaxMetaspaceSize.

Jarayonning RSSʼi heapʼdan ancha katta. Xotira yana qayerga ketadi?Javob
Qisqa javob

Heapʼdan tashqari xotiraga: Metaspace, JIT code cache, har bir threadʼning stackʼi, GCʼning ichki tuzilmalari, direct bufferʼlar va native kutubxonalar. Buni Native Memory Tracking boʻlimlarga ajratib koʻrsatadi.

Direct buffer heapʼdan tashqarida ajratiladi va I/O uchun qulay: maʼlumot socket yoki faylga qoʻshimcha nusxalashsiz beriladi. Lekin uning xotirasi faqat ByteBuffer obyektining oʻzi GC qilinganda boʻshaydi. Obyekt kichik va old generationʼda yashasa, GC uni uzoq vaqt tozalamaydi va native xotira toʻplanib qoladi. Limit — -XX:MaxDirectMemorySize, default — maksimal heap oʻlchami.

Har bir platform thread -Xss hajmida stack uchun joy band qiladi (Linux x64 da 1 MB), RSSʼga esa faqat haqiqatda ishlatilgan qismi tushadi. Baribir 2000 thread — jiddiy xotira va OS resursi. Threadʼlar juda koʻpaysa, OutOfMemoryError: unable to create native thread chiqadi. Koʻp vaqtini kutishda oʻtkazadigan vazifalar uchun Java 21 dagi virtual threadʼlar bu muammoni yechadi.

Code cache — JIT kompilyatsiya qilgan mashina kodi, Java 9 dan uch segmentga boʻlingan. U toʻlsa, JVM «… is full. Compiler has been disabled.» deb ogohlantiradi va yangi kod endi kompilyatsiya qilinmaydi — ilova sezilarli sekinlashadi. Hajmi — -XX:ReservedCodeCacheSize, tiered compilation bilan default 240 MB.

jcmd <pid> VM.native_memory summary
# misol, qisqartirilgan
-  Java Heap (reserved=2097152KB, committed=2097152KB)
-      Class (reserved=1056768KB, committed=13056KB)
-     Thread (reserved=210944KB, committed=18432KB)
-       Code (reserved=247744KB, committed=46264KB)
-         GC (reserved=110588KB, committed=110588KB)
-      Other (reserved=524288KB, committed=524288KB)
OutOfMemoryErrorning qanday turlari bor va productionʼda ularni qanday tahlil qilasiz?Javob
Qisqa javob

Xabar qaysi xotira tugaganini aytadi: Java heap space, Metaspace, unable to create native thread, GC overhead limit exceeded, Requested array size exceeds VM limit va direct buffer xatosi. Har birining sababi va tahlil vositasi har xil, shuning uchun tahlil xabarni oʻqishdan boshlanadi.

Java heap space — heap toʻla: leak yoki heap tirik maʼlumot uchun kichik; vosita — heap dump. GC overhead limit exceeded (Parallel, yangi buildʼlarda G1 ham) — xuddi shu muammo, faqat JVM ilova deyarli faqat GC bilan band boʻlib qolganini oldinroq sezgan. Requested array size exceeds VM limit — Integer.MAX_VALUE atrofidagi oʻlchamli massiv soʻralgan, odatda oʻlcham xato hisoblangan.

Metaspace — klasslar juda koʻp: ClassLoader leak yoki klasslarni dinamik generatsiya qilish; vosita — jcmd <pid> VM.classloader_stats va heap dumpʼdagi loaderʼlar. unable to create native thread — OS yangi thread bermadi: threadʼlar juda koʻp (ulimit -u, konteynerning pids limiti) yoki native xotira tugagan; vosita — jcmd <pid> Thread.print: qaysi pool threadʼlari koʻpaygan. Cannot reserve … bytes of direct buffer memory — MaxDirectMemorySize tugagan.

Productionʼga oldindan tayyorlanish kerak: -XX:+HeapDumpOnOutOfMemoryError va boʻsh joyi yetarli -XX:HeapDumpPath, faylga yoziladigan GC logi va -XX:+ExitOnOutOfMemoryError — OOMʼdan keyin jarayon chala holatda ishlashda davom etmaydi, toʻxtaydi va orkestrator uni qayta ishga tushiradi.

-XX:+HeapDumpOnOutOfMemoryError
-XX:HeapDumpPath=/dumps
-XX:+ExitOnOutOfMemoryError
'-Xlog:gc*:file=gc.log:time,uptime:filecount=5,filesize=20M'

9JIT, warm-up va profiling

HotSpot kodni bir necha darajada bajaradi — bu tiered compilation, Java 8 dan default. Metod avval interpretatorda ishlaydi. Yuzlab marta chaqirilgach, uni C1 kompilyatori tez kompilyatsiya qiladi va kodga profil yigʻadigan hisoblagichlar qoʻshadi. Minglab chaqiruvdan keyin C2 shu profil asosida chuqur optimallashgan kod yaratadi: inlining, escape analysis, loop unrolling, vectorization.

DarajaKim bajaradiXususiyati
0interpretatordarhol ishlaydi, sekin; profil yigʻiladi
1–3C1tez kompilyatsiya; 2-darajada faqat hisoblagichlar, 3-darajada toʻliq profil
4C2sekin kompilyatsiya, eng tez kod; profil asosida taxminlar qiladi

C2 taxminlarga tayanadi: «bu if hech qachon bajarilmagan», «bu chaqiruvga doim ArrayList keladi». Taxmin buzilsa — masalan, shu paytgacha hech qayerda override qilinmagan metodni override qiladigan yangi klass yuklansa — kompilyatsiya qilingan kod bekor qilinadi va bajarilish interpretatorga qaytadi. Bu deoptimization: metod keyin yangi profil bilan qayta kompilyatsiya qilinadi.

Shuning uchun Java servisi ishga tushgandan keyin bir muddat sekin ishlaydi: klasslar yuklanadi, kod interpretatorda bajariladi, JIT esa CPUʼni ilova bilan boʻlishadi. Bu warm-up. Birinchi soʻrovlarning latencyʼsi bir necha baravar yuqori boʻlishi mumkin, ayniqsa CPU limiti kichik konteynerda.

Sekin joy taxmin bilan emas, profiler bilan topiladi. JFR — JDK Flight Recorder — JVMʼga qurilgan: u CPU sampleʼlari, allokatsiyalar, GC, lock va I/O eventʼlarini kam overhead bilan yozadi, shuning uchun productionʼda ham ishlatsa boʻladi. async-profiler — Linux va macOS uchun sampling profiler: CPU, allokatsiya, lock va wall-clock rejimlari bor va natijani flame graph qilib beradi.

# JFR: 60 sekund yozish
jcmd <pid> JFR.start duration=60s \
  settings=profile filename=app.jfr
# Java 21+: tayyor hisobotlar
jfr view hot-methods app.jfr
jfr view allocation-by-site app.jfr

# async-profiler: CPU va allokatsiya
asprof -d 30 -f cpu.html <pid>
asprof -e alloc -d 30 -f alloc.html <pid>

Flame graphʼda har bir toʻrtburchak — stackʼdagi bitta metod, uning ustida — u chaqirgan metodlar. Toʻrtburchakning eni — shu metod, u chaqirganlar bilan birga, sampleʼlarning qancha qismida uchragani. Chapdan oʻngga tartib vaqtni emas, alifbo tartibini bildiradi. Eng tepadagi keng toʻrtburchaklar — CPU vaqti haqiqatan sarflangan joylar.

Tushunganingizni tekshiring

Tiered compilation qanday ishlaydi va deoptimization nima uchun boʻladi?Javob
Qisqa javob

Metod avval interpretatorda ishlaydi va profil yigʻadi. Issiq boʻlsa, uni C1 tez kompilyatsiya qiladi, yanada issiq boʻlsa — C2 profil asosida chuqur optimallashtiradi. C2 taxminlari buzilsa, kod bekor qilinadi va interpretatorga qaytiladi — bu deoptimization.

C1 va C2 kompromissni boʻlishadi: C1 tez kompilyatsiya qiladi, lekin oddiyroq kod beradi; C2 sekin kompilyatsiya qiladi, lekin eng tez kod beradi. Ikkalasi birga boʻlgani uchun dastur tez tezlasha boshlaydi va keyin maksimal tezlikka chiqadi.

C2 profil koʻrsatgan narsaga tayanadi. Chaqiruv joyiga faqat bitta tur kelsa, u virtual chaqiruvni toʻgʻridan-toʻgʻri chaqiruvga aylantiradi va inline qiladi; hech qachon bajarilmagan branch kodga umuman kiritilmaydi. Shunday taxmin buzilganda — yangi tur keldi, «hech qachon» bajarilmagan branch bajarildi, yangi klass yuklandi — deoptimization boʻladi.

Bir martalik deoptimization normal holat. Muammo — u qayta-qayta takrorlansa: masalan, issiq chaqiruv joyiga ishdan biroz keyin yangi turlar kela boshlasa. Buni -XX:+PrintCompilation (made not entrant qatorlari) yoki jfr view deoptimizations-by-reason koʻrsatadi.

Servis ishga tushgandan keyingi birinchi soʻrovlar nega sekin va productionʼda buni qanday hal qilasiz?Javob
Qisqa javob

Klasslar hali yuklanmagan, kod interpretatorda ishlaydi, JIT CPUʼni ilova bilan boʻlishadi; ustiga framework, connection pool va cacheʼlar lazy initsializatsiya qilinadi. Yechim — trafikni warm-up tugagandan keyin berish: sinov soʻrovlari, readiness probe, trafikni asta-sekin oshirish. Startupʼni esa CDS va AOT cache tezlashtiradi.

Kubernetesʼda readiness probe servis ishga tushganda emas, isigandan keyin muvaffaqiyatli boʻlishi kerak: ishga tushishda asosiy endpointʼlarga bir necha ming sinov soʻrovi yuboriladi, connection pool va cacheʼlar toʻldiriladi. Load balancerʼda yangi instanceʼga trafik asta-sekin oshiriladi — koʻp load balancerʼlarda bu slow start deyiladi.

CPU limiti kichik konteynerda warm-up uzayadi: JIT threadʼlari ham shu limitdan foydalanadi. Ishga tushish paytida koʻproq CPU berish — Kubernetesʼda request va limitni toʻgʻri tanlash — koʻpincha eng oddiy yechim.

JDK oʻzi ham yordam beradi. CDS — Class Data Sharing — JDK klasslarini oldindan tayyorlangan arxivdan yuklaydi va Java 12 dan default yoqilgan; AppCDS ilova klasslari uchun ham shunday arxiv yaratadi. Java 24 dan AOT cache — Project Leyden natijasi — bundan ham koʻp narsani oldindan saqlaydi: yuklangan va bogʻlangan klasslarni, Java 25 da esa oldingi ishga tushirishdagi method profillarini ham — JIT issiq kodni ertaroq kompilyatsiya qiladi.

# Java 25: sinov ishga tushirishda cache yaratish
java -XX:AOTCacheOutput=app.aot -jar app.jar

# productionʼda cache bilan
java -XX:AOTCache=app.aot -jar app.jar
Sekin kod va ortiqcha allokatsiyani qanday topasiz? Flame graph qanday oʻqiladi?Javob
Qisqa javob

Profiler bilan: JFR yoki async-profiler CPU sampleʼlarini va allokatsiyalarni yozadi, natija flame graph yoki jadval boʻlib chiqadi. Flame graphʼda eni — vaqt yoki allokatsiya ulushi: eng tepadagi keng toʻrtburchaklar — resurs haqiqatan sarflangan metodlar.

Sampling profiler har bir necha millisekundda threadʼlarning stackʼini oladi va qaysi metodlar koʻp uchrashini sanaydi. Eski profilerʼlar stackʼni faqat safepointʼda olardi va safepointʼlar orasidagi kodni koʻrmasdi — bu safepoint bias. JFR va async-profiler stackʼni safepointʼni kutmasdan oladi, shuning uchun ularning natijasi aniqroq.

Ortiqcha allokatsiya GC orqali qimmatga tushadi: allocation rate oshadi va young GC tez-tez boʻladi. Allokatsiya profilida (asprof -e alloc yoki JFRʼdagi jdk.ObjectAllocationSample) koʻp uchraydigan manbalar: issiq sikldagi boxing, sikl ichida String birlashtirish, log darajasi oʻchirilgan boʻlsa ham qator yasaydigan log.debug("x=" + x), har chaqiruvda Pattern.compile, keraksiz kolleksiya nusxalari.

Flame graphʼda avval eng tepadagi keng «platolar» qidiriladi — oʻz vaqtini koʻp olgan metodlar. Keyin pastga qarab, ularni kim chaqirgani topiladi. Ranglar odatda faqat frame turini bildiradi — Java, native yoki kernel — «yomon» yoki «yaxshi» degani emas. Optimallashtirgandan keyin yana oʻlchash kerak: oʻzgarish profilda koʻrinishi kerak.

Tushunganingizni suhbatda sinab koʻring

Mavzuli mock intervyuda «JVM va xotira»ni tanlang. AI shu kabi savollarni beradi, javobingizga qarab chuqurroq savol soʻraydi va har javobingizga fikr bildiradi.

Mock intervyuni boshlash