Java Concurrency: threadʼlar, lockʼlar va memory model qanday ishlaydi
Bu sahifa Java concurrency mavzusini chuqur tushuntiradi: threadʼlar qanday ishlaydi, nega bir nechta thread bitta maʼlumot bilan ishlaganda xato chiqadi, Java Memory Model nimani kafolatlaydi va java.util.concurrent vositalaridan qachon qaysi birini tanlash kerak. Murakkab joylar qadamma-qadam animatsiya bilan koʻrsatilgan.
Boʻlimlar asoslardan chuqurroq mavzularga qarab ketadi: thread va synchronizedʼdan virtual threadʼlar va productionʼdagi muammolarni topishgacha. Bilgan joyingizni oʻtkazib yuborishingiz yoki istalgan boʻlimdan boshlashingiz mumkin. Kod Java 21 da 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.
1Thread: yaratish, lifecycle va toʻxtatish
Process — ishlab turgan dastur: uning oʻz xotirasi, ochiq fayllari va boshqa resurslari bor, boshqa processlar unga toʻgʻridan-toʻgʻri tegolmaydi. Thread — process ichida kodni bajarib boradigan birlik: har bir threadʼning oʻz stackʼi bor, heap va undagi hamma obyektlar esa shu processdagi barcha threadʼlar uchun umumiy. Bitta JVM — bitta process: unda main thread va GC, JIT kabi xizmat threadʼlari ishlaydi.
Threadʼlar umumiy xotirani boʻlishgani uchun maʼlumot almashish arzon — oddiy obyekt orqali. Lekin concurrencyʼdagi deyarli hamma muammo ham shundan: ikki thread bitta obyekt bilan bir vaqtda ishlasa, natija kutilmagan boʻlishi mumkin. Keyingi boʻlimlar shu haqida.
Thread yaratishning asosiy yoʻli — bajariladigan ishni Runnable sifatida berish. start() yangi thread yaratadi va run()ni oʻsha threadʼda chaqiradi, run()ni toʻgʻridan-toʻgʻri chaqirish esa oddiy metod chaqiruvi:
Runnable task = () -> System.out.println(
"Salom, " + Thread.currentThread().getName());
Thread t = new Thread(task, "worker-1");
t.start(); // yangi thread: "Salom, worker-1"
t.join(); // main t tugashini kutadi
task.run(); // yangi thread yoʻq: "Salom, main"
// Java 21: builder
Thread.ofPlatform().name("worker-2").start(task);Thread har doim oltita Thread.State holatidan birida boʻladi. Bu holatlarni thread dumpʼda koʻrasiz, shuning uchun ularning farqini bilish foydali:
| Holat | Qachon | Misol |
|---|---|---|
NEW | yaratilgan, start() hali chaqirilmagan | new Thread(task) |
RUNNABLE | ishlayapti yoki CPU navbatini kutyapti | hisob-kitob; platform threadʼning socketdan oʻqishi ham shu holatda koʻrinadi |
BLOCKED | synchronizedga kirish uchun monitorni kutyapti | monitorni boshqa thread ushlab turibdi |
WAITING | muddatsiz kutyapti, uni boshqa thread uygʻotishi kerak | wait(), join(), ReentrantLock.lock() |
TIMED_WAITING | muddat bilan kutyapti | sleep(100), wait(100), join(100) |
TERMINATED | run() tugagan — oddiy yoki exception bilan | qayta start() qilib boʻlmaydi |
Threadʼni tashqaridan majburan toʻxtatib boʻlmaydi. Thread.stop() threadʼni istalgan joyda uzib qoʻyardi va u ushlab turgan hamma lockʼlarni boʻshatardi: yarim oʻzgargan obyektlar boshqa threadʼlarga koʻrinib qolardi. U Java 1.2 dan beri deprecated, Java 20 dan beri esa faqat UnsupportedOperationException tashlaydi. Toʻgʻri yoʻl — kelishuv: interrupt() threadʼga «toʻxta» degan iltimos yuboradi, thread esa uni tekshirib, ishini tartib bilan yakunlaydi.
Daemon thread — fon ishlari uchun. JVM oxirgi non-daemon, yaʼni oddiy thread tugashi bilan toʻxtaydi va ishlab turgan daemon threadʼlarni kutmaydi. Yangi thread daemon boʻlish-boʻlmasligini uni yaratgan threadʼdan oladi; main — non-daemon.
Tushunganingizni tekshiring
Process va thread farqi nimada?Javob
Process — oʻz xotirasi va resurslari boʻlgan ishlab turgan dastur. Thread — process ichida kod bajaradigan birlik: har bir threadʼning oʻz stackʼi bor, heap esa shu processdagi hamma threadʼlar uchun umumiy.
Processlar bir-biridan ajratilgan: biri ikkinchisining xotirasini oʻqiy olmaydi, maʼlumot almashish uchun socket, fayl yoki pipe kerak. Threadʼlar esa bitta obyektga toʻgʻridan-toʻgʻri murojaat qiladi — bu tez, lekin sinxronizatsiyasiz xavfli.
Oddiy Java thread, yaʼni platform thread, operatsion tizim threadʼiga 1:1 bogʻlangan: uni OS scheduler rejalashtiradi, stackʼi uchun esa oldindan joy band qilinadi — platformaga qarab 1–2 MB (-Xss). Shuning uchun minglab platform thread qimmat; thread pool va virtual threadʼlar shu muammoni hal qiladi.
Bitta threadʼda ushlanmagan exception faqat oʻsha threadʼni tugatadi, JVM ishlashda davom etadi: exception UncaughtExceptionHandlerga tushadi, default holatda uning stack trace chiqariladi.
start() va run() farqi nima?Javob
start() yangi thread yaratadi va run()ni oʻsha threadʼda chaqiradi. run()ni toʻgʻridan-toʻgʻri chaqirsangiz, bu oddiy metod chaqiruvi: kod joriy threadʼda bajariladi, hech qanday parallellik yoʻq.
start() JVMga yangi OS thread yaratishni aytadi va darhol qaytadi; thread NEW holatdan RUNNABLEga oʻtadi. run() qachon boshlanishini scheduler hal qiladi, shuning uchun start()dan keyingi qator yangi thread ishlay boshlashidan oldin ham, keyin ham bajarilishi mumkin.
start()ni bitta Thread obyektida ikki marta chaqirib boʻlmaydi: ikkinchisi IllegalThreadStateException tashlaydi, thread allaqachon tugagan boʻlsa ham. Ishni qayta bajarish uchun yangi Thread yaratiladi yoki vazifa thread poolʼga beriladi.
Threadʼni qanday toʻgʻri toʻxtatish kerak? InterruptedExceptionni ushlaganda nima qilish kerak?Javob
interrupt() bilan: u threadʼning interrupt flagʼini qoʻyadi, kutib turgan thread esa InterruptedException bilan uygʻonadi. Thread flagʼni tekshirib, ishini tartib bilan yakunlaydi. InterruptedExceptionni jimgina yutib yuborib boʻlmaydi: uni yuqoriga tashlash yoki flagʼni qayta qoʻyish kerak.
Interrupt — majburlash emas, kelishuv. Thread uni ikki joyda koʻradi: bloklovchi metodlar (sleep, wait, join, BlockingQueue.take, Future.get) InterruptedException tashlaydi, hisob-kitob siklida esa Thread.currentThread().isInterrupted() tekshiriladi. Statik Thread.interrupted() ham bor, lekin u flagʼni tekshiribgina qolmay, tozalab ham yuboradi.
InterruptedException tashlanganda flag allaqachon tozalangan boʻladi. catch blokda hech narsa qilinmasa, «toʻxta» degan iltimos yoʻqoladi: yuqoridagi kod, masalan thread pool, threadʼni toʻxtatish kerakligini bilmay qoladi. Shuning uchun ikki yoʻl bor: metodga throws InterruptedException qoʻshib, exceptionʼni yuqoriga chiqarish yoki Thread.currentThread().interrupt() bilan flagʼni qayta qoʻyish.
Har qanday kutish interruptʼga javob bermaydi. synchronizedga kirishni kutayotgan thread interrupt boʻlsa ham monitorni kutaveradi, ReentrantLock.lockInterruptibly() esa kutishni toʻxtatadi. Platform threadʼda oddiy java.net.Socketdan oʻqish ham interruptʼga javob bermaydi: bunday threadʼni socketʼni yopib uygʻotish mumkin. Virtual threadʼda esa (Java 21) interrupt socketʼni oʻzi yopadi va threadʼni uygʻotadi.
class Worker implements Runnable {
private final BlockingQueue<Job> jobs;
Worker(BlockingQueue<Job> q) { jobs = q; }
@Override
public void run() {
Thread me = Thread.currentThread();
try {
while (!me.isInterrupted()) {
// interrupt boʻlsa, take() tashlaydi
Job job = jobs.take();
job.execute();
}
} catch (InterruptedException e) {
// flagʼni qayta qoʻyamiz va chiqamiz
Thread.currentThread().interrupt();
}
}
}2Race condition, synchronized va deadlock
Race condition — natija threadʼlar qaysi tartibda ishlaganiga bogʻliq boʻlib qoladigan holat. Eng oddiy misol — umumiy hisoblagich. count++ bitta amaldek koʻrinadi, aslida esa uchta: qiymatni oʻqish, unga 1 qoʻshish va natijani qaytarib yozish. Ikki thread bu qadamlarni aralashtirib bajarsa, bitta qoʻshish yoʻqoladi:
countni bittadan oshirmoqchi, hozir count = 0. count++ aslida uch qadam: oʻqish, 1 qoʻshish va yozish.Bunday xato tasodifiy chiqadi: test 1000 marta toʻgʻri ishlashi, productionʼda esa yuk oshganda buzilishi mumkin. Yechim — oʻqish, oʻzgartirish va yozishni bitta atomik amalga aylantirish: yo lock bilan, yo atomik klass bilan (AtomicInteger.incrementAndGet()). Kolleksiyalardagi check-then-act xatosi — if (!map.containsKey(k)) map.put(k, v) — ham xuddi shunday race condition: har bir metod thread-safe boʻlsa ham, ularning ketma-ketligi atomik emas.
synchronized — Javaʼning oʻrnatilgan lockʼi. Har bir obyektga monitor bogʻlangan: synchronized (obj) { ... } blokiga kirgan thread objning monitorini oladi va chiqishda — exception bilan chiqsa ham — qaytarib beradi. Monitorni bir vaqtda faqat bitta thread ushlab turadi, qolganlari BLOCKED holatda kutadi. synchronized instance metod thisni, static synchronized metod esa klassning Class obyektini lock qiladi.
synchronized ikki narsa beradi: mutual exclusion — blokda bir vaqtda faqat bitta thread — va visibility: blokda yozilgan qiymatlarni shu monitorni keyin olgan thread albatta koʻradi. Ikkinchisi keyingi boʻlimning mavzusi.
Lockʼlar koʻp boʻlsa, deadlock xavfi paydo boʻladi: T1 A lockʼni ushlab, B ni kutadi, T2 esa B ni ushlab, A ni kutadi. Ikkalasi abadiy kutadi, chunki synchronizedda kutishni bekor qilib boʻlmaydi. Eng ishonchli himoya — lockʼlarni hamma joyda bir xil tartibda olish.
Tushunganingizni tekshiring
count++ nega thread-safe emas?Javob
Chunki u bitta amal emas: qiymatni oʻqish, 1 qoʻshish va natijani qaytarib yozish. Ikki thread bir xil eski qiymatni oʻqib, ikkalasi bir xil natijani yozsa, bitta qoʻshish yoʻqoladi — bu lost update.
Bytecodeʼda bu alohida instruksiyalar: getfield — oʻqish, iadd — qoʻshish, putfield — yozish. Thread ularning istalgan joyida toʻxtatilishi mumkin, boshqa thread esa shu orada xuddi shu fieldʼni oʻqiydi.
Ikki thread 100 000 martadan oshirsa, natija koʻpincha 200 000 dan kam chiqadi va har ishga tushirishda boshqacha boʻladi. Baʼzan toʻgʻri chiqishi ham mumkin — bu xatoni yanada xavfli qiladi: test oʻtadi, production esa buziladi.
Yechimlar: synchronized metod yoki blok, AtomicInteger.incrementAndGet() — lockʼsiz, CAS asosida — yoki koʻp thread tez-tez yozadigan hisoblagich uchun LongAdder.
class Counter {
private int count;
void inc() { count++; } // race condition
int get() { return count; }
}
Counter c = new Counter();
Runnable r = () -> {
for (int i = 0; i < 100_000; i++) c.inc();
};
Thread t1 = new Thread(r), t2 = new Thread(r);
t1.start(); t2.start();
t1.join(); t2.join();
// koʻpincha 200 000 dan kam chiqadi
System.out.println(c.get());synchronized qanday ishlaydi va u aslida nimani lock qiladi?Javob
Har bir obyektga monitor bogʻlangan. synchronized blokka kirgan thread shu monitorni oladi, chiqishda qaytarib beradi; bu orada shu monitorni olmoqchi boʻlgan boshqa threadʼlar kutadi. Lock kodga emas, obyektga qoʻyiladi: instance metodda — this, static metodda — klassning Class obyekti.
Ikki thread bitta synchronized metodni har xil obyektlarda chaqirsa, ular bir-birini kutmaydi. Aksincha, bitta obyektning ikki xil synchronized metodi bir-birini toʻsadi, chunki monitor bitta. static synchronized va oddiy synchronized metodlar esa har xil monitorni ishlatadi va bir-birini toʻsmaydi.
synchronized reentrant: monitorni ushlab turgan thread unga yana kira oladi, masalan synchronized metod shu obyektning boshqa synchronized metodini chaqirganda. JVM kirishlar sonini sanaydi va monitor oxirgi chiqishda boʻshaydi. Exception bilan chiqilganda ham monitor qaytariladi — finally yozish shart emas.
Lock uchun alohida private final Object lock ishlatish yaxshi odat: thisni tashqi kod ham lock qilib, kutilmagan kutishlarga sabab boʻlishi mumkin. String literali yoki Integer kabi qayta ishlatiladigan obyekt ustida lock qilish xavfli — xuddi shu obyekt boshqa kodda ham lock boʻlishi mumkin.
class Account {
private final Object lock = new Object();
private long balance;
void deposit(long amount) {
synchronized (lock) {
balance += amount;
}
}
long balance() {
// oʻqish ham shu lock ostida: visibility uchun
synchronized (lock) {
return balance;
}
}
}Deadlock qanday paydo boʻladi va undan qanday saqlanish mumkin?Javob
Ikki yoki undan koʻp thread bir-biri ushlab turgan lockʼni kutib qolganda: T1 A ni ushlab B ni kutadi, T2 B ni ushlab A ni kutadi. Eng ishonchli himoya — lockʼlarni hamma joyda bir xil tartibda olish.
Deadlock uchun toʻrt shart birga boʻlishi kerak: mutual exclusion — lockʼni bir vaqtda bitta thread ushlaydi; hold and wait — thread bitta lockʼni ushlab turib, boshqasini kutadi; no preemption — lockʼni tortib olib boʻlmaydi; circular wait — kutishlar halqa hosil qiladi. Birortasini buzish deadlockʼni yoʻqotadi, amalda eng osoni — halqani buzish.
Klassik misol — pul oʻtkazish: transfer(a, b) avval ani, keyin bni lock qiladi. Bir vaqtda transfer(x, y) va transfer(y, x) chaqirilsa — deadlock. Yechim — lockʼlarni tartib bilan olish: pul qaysi tomonga oʻtkazilmasin, idsi kichik hisob birinchi lock qilinadi.
Boshqa yoʻl — ReentrantLock.tryLock(timeout): lockʼni ololmagan thread kutishni toʻxtatadi, ushlab turganlarini qoʻyib yuboradi va keyinroq qayta urinadi. Deadlock yuz berib qolsa, uni thread dumpʼdan topish mumkin — oxirgi boʻlimda.
void transfer(Account from, Account to, long sum) {
// lockʼlar doim id boʻyicha tartibda olinadi
Account first = from.id() < to.id() ? from : to;
Account second = first == from ? to : from;
synchronized (first) {
synchronized (second) {
from.withdraw(sum);
to.deposit(sum);
}
}
}3Visibility, volatile va happens-before
Bitta threadʼda yozilgan qiymatni boshqa thread darhol koʻrishi kafolatlanmagan. Sabab — tezlik uchun qilinadigan optimizatsiyalar. JIT kompilyator fieldʼni registerda saqlab, siklda xotiradan qayta oʻqimasligi mumkin. CPU yozuvni avval store bufferʼga qoʻyadi va boshqa yadro uni biroz keyin koʻradi. Ikkalasi ham bir-biriga bogʻliq boʻlmagan amallarning tartibini oʻzgartirishi mumkin.
Buni koʻpincha «har bir thread oʻz CPU cacheʼi bilan ishlaydi» deb soddalashtiriladi. Model sifatida foydali, lekin aniq emas: zamonaviy CPUʼlarda cacheʼlar bir-biri bilan muvofiqlashtirilgan, muammo registerlar, bufferlar va qayta tartiblashda. Bitta thread ichida bu sezilmaydi — optimizatsiya uning natijasini oʻzgartirmaydi. Boshqa thread esa yozuvlarni kechikib, boshqa tartibda yoki umuman koʻrmasligi mumkin.
Java Memory Model (JMM) koʻrinish qachon kafolatlanganini happens-before munosabati orqali belgilaydi: A amal B dan happens-before boʻlsa, A va undan oldingi hamma yozuvlar B ni bajarayotgan threadʼga koʻrinadi. Bu munosabatni quyidagilar yaratadi:
| Qoida | Nima kafolatlanadi |
|---|---|
| program order | bitta thread ichida har bir amal keyingisidan happens-before |
| monitor | monitorni boʻshatish — synchronizeddan chiqish — shu monitorni keyin olishdan happens-before |
volatile | volatile fieldʼga yozish shu fieldʼni keyin oʻqishdan happens-before |
Thread.start() | start() chaqiruvi yangi threadʼdagi har bir amaldan happens-before |
Thread.join() | threadʼdagi hamma amallar boshqa threadʼda uning join()i qaytishidan happens-before |
java.util.concurrent | navbatga put → shu elementni take; submit → vazifaning bajarilishi; vazifa → future.get() qaytishi |
| tranzitivlik | A → B va B → C boʻlsa, A → C |
volatile field ikki narsa beradi. Visibility: har bir oʻqish oxirgi yozilgan qiymatni koʻradi. Tartib: volatile yozishdan oldingi oddiy yozuvlar ham u bilan birga koʻrinadi. Shuning uchun volatile flag orqali maʼlumotni boshqa threadʼga xavfsiz uzatish mumkin:
data = 42, keyin ready = true. T2 flagni kutadi va datani oʻqiydi. Boshida umumiy xotirada data = 0, ready = false.class Publisher {
int data;
volatile boolean ready;
void publish() { // T1
data = 42;
ready = true;
}
void consume() { // T2
while (!ready) Thread.onSpinWait();
System.out.println(data); // doim 42
}
}volatile atomiklik bermaydi: count++ volatile field bilan ham xato. U bitta thread yozib, boshqalar oʻqiydigan holatlar uchun — flag, holat, bir marta eʼlon qilinadigan obyekt reference uchun. final fieldʼlarning ham alohida kafolati bor: konstruktor tugagach, final fieldʼlar obyektni koʻrgan har qanday threadʼga toʻliq koʻrinadi — agar konstruktorda this tashqariga chiqib ketmagan boʻlsa. Immutable obyektlarni shuning uchun threadʼlar orasida qoʻshimcha sinxronizatsiyasiz uzatsa boʻladi.
Tushunganingizni tekshiring
Bitta thread while (running) siklida ishlayapti, boshqasi running = false qiladi. Nega sikl hech qachon tugamasligi mumkin va volatile nimani tuzatadi?Javob
running oddiy field: JIT uni bir marta oʻqib, keyin registerdagi qiymat bilan ishlashi mumkin, chunki bu threadʼning oʻzi uni oʻzgartirmaydi. Boshqa thread yozgan false hech qachon koʻrinmaydi. volatile har bir oʻqishni haqiqiy oʻqish qiladi va yozuv boshqa threadʼlarga koʻrinadi.
JMM nuqtai nazaridan stop()dagi yozuv bilan loop()dagi oʻqish orasida happens-before yoʻq. Demak kompilyator while (running)ni if (running) while (true)ga aylantirishga haqli. HotSpot amalda koʻpincha shunday qiladi: sikl koʻp aylangach JIT uni kompilyatsiya qiladi va oʻqish sikldan tashqariga chiqadi.
volatile bilan har bir oʻqish xotiradan olinadi, yozish esa boshqa threadʼlarga koʻrinadi. Bundan tashqari, volatile yozish va oʻqish atrofida amallarni qayta tartiblash cheklanadi: yozishdan oldingi amallar oʻqishdan keyingi amallarga koʻrinadi.
Muqobillar: AtomicBoolean, synchronized getter va setter yoki flag oʻrniga interrupt. Thread kutishda ham turishi mumkin boʻlsa, interrupt yaxshiroq: u sleep yoki takeda turgan threadʼni ham uygʻotadi.
class Loop {
private boolean running = true;
void stop() { running = false; } // T1 chaqiradi
void loop() { // T2 bajaradi
long n = 0;
while (running) n++;
System.out.println("toʻxtadi: " + n);
}
}Happens-before nima? U «vaqt boʻyicha oldin» degani emasmi?Javob
Happens-before — JMMʼdagi koʻrinish kafolati: A amal B dan happens-before boʻlsa, A gacha qilingan hamma yozuvlar B ga koʻrinadi. Bu vaqt boʻyicha tartib emas: sinxronizatsiyasiz oʻqish vaqt boʻyicha keyin boʻlsa ham eski qiymatni qaytarishi mumkin. Munosabatni program order, monitor, volatile, start va join hamda java.util.concurrent vositalari yaratadi.
Ikki thread bitta fieldʼga sinxronizatsiyasiz murojaat qilsa va kamida bittasi yozsa, bu data race. Data race boʻlgan joyda oʻqish eski qiymatni ham, yangisini ham qaytarishi mumkin, va ikkalasi ham JMM ruxsat bergan natija.
Kuchi tranzitivlikda. T1: data = 42; ready = true;, bunda ready — volatile. T2: if (ready) print(data);. Program order boʻyicha data = 42 → ready = true, volatile qoidasi boʻyicha ready = true → T2 dagi oʻqish, demak data = 42 → print(data): T2 albatta 42 ni koʻradi. ready oddiy field boʻlsa, T2 ready == trueni koʻrib, data uchun 0 ni olishi mumkin.
java.util.concurrent ham shunday kafolat beradi: BlockingQueue.putdan oldingi amallar shu elementni take qilgan threadʼga, executor.submitdan oldingi amallar vazifaning oʻziga, vazifadagi amallar esa future.get() qaytgandan keyingi kodga koʻrinadi. Shuning uchun navbat yoki executor orqali uzatilgan oddiy obyektga qoʻshimcha volatile kerak emas — agar keyin uni hech kim oʻzgartirmasa.
4Kutish: wait/notify, BlockingQueue va synchronizerʼlar
Koʻpincha thread biror shart bajarilishini kutishi kerak: navbatda element paydo boʻlishini yoki boshqa threadʼlar ishini tugatishini. Siklda tekshirib turish — busy-wait — CPUʼni bekorga band qiladi. Eng past darajadagi vosita — Objectning wait() va notify() metodlari.
wait() faqat shu obyektning monitori ushlab turilganda chaqiriladi, aks holda IllegalMonitorStateException. U monitorni boʻshatadi va threadʼni obyektning wait setʼiga qoʻyadi. notify() u yerdan bitta threadʼni, notifyAll() esa hammasini uygʻotadi. Uygʻongan thread wait()dan darhol qaytmaydi: avval monitorni qayta olishi kerak, bu orada shart yana oʻzgarib qolishi mumkin. Bundan tashqari, thread hech kim notify qilmasa ham uygʻonishi mumkin — spurious wakeup. Shuning uchun shart doim while siklida tekshiriladi:
class Box<T> {
private T item;
synchronized void put(T x)
throws InterruptedException {
while (item != null) wait();
item = x;
notifyAll();
}
synchronized T take()
throws InterruptedException {
while (item == null) wait();
T x = item;
item = null;
notifyAll();
return x;
}
}java.util.concurrent.locksda wait/notifyning muqobili bor — Condition. lock.newCondition() bitta lock uchun alohida kutish navbatini beradi, har bir shartga bittadan. await() lockʼni boʻshatib kutadi va wait() kabi while siklida chaqiriladi, signal() esa faqat shu shartni kutayotgan threadʼlardan birini uygʻotadi. Shunda producer faqat consumerʼni, consumer faqat producerʼni uygʻotadi va notifyAll bilan hammani bekorga uygʻotish kerak boʻlmaydi:
class Slot<T> {
final Lock lock = new ReentrantLock();
final Condition notEmpty = lock.newCondition();
final Condition notFull = lock.newCondition();
T item;
void put(T x) throws InterruptedException {
lock.lock();
try {
while (item != null) notFull.await();
item = x;
notEmpty.signal(); // faqat consumerʼni
} finally {
lock.unlock();
}
}
T take() throws InterruptedException {
lock.lock();
try {
while (item == null) notEmpty.await();
T x = item;
item = null;
notFull.signal(); // faqat producerʼni
return x;
} finally {
lock.unlock();
}
}
}Bunday kodni toʻgʻri yozish oson emas, shuning uchun amalda tayyor vositalar ishlatiladi. BlockingQueue producer-consumer patternʼini toʻliq beradi: put navbat toʻla boʻlsa joy boʻshaguncha, take boʻsh boʻlsa element kelguncha kutadi. Producer va consumerʼlar bir-birini bilmaydi, cheklangan navbat esa tez producerʼni avtomatik sekinlashtiradi — bu backpressure.
ArrayBlockingQueue — oʻlchami qatʼiy massiv va bitta lock. LinkedBlockingQueue — nodeʼlar zanjiri va ikkita lock: biri put, biri take uchun, shuning uchun producer va consumer bir-birini kamroq toʻsadi; lekin oʻlcham berilmasa, u amalda cheksiz. SynchronousQueueda umuman joy yoʻq: put boshqa thread elementni take qilguncha kutadi.
Kutishning boshqa koʻp uchraydigan shakllari uchun java.util.concurrentda synchronizerʼlar bor:
| Vosita | Nima qiladi | Qayta ishlatiladimi | Misol |
|---|---|---|---|
CountDownLatch | hisoblagich nolga tushguncha kutadi: countDown() kamaytiradi, await() kutadi | yoʻq, bir martalik | servis uchta komponent tayyor boʻlguncha kutadi |
CyclicBarrier | N ta thread bir nuqtada bir-birini kutadi, keyin hammasi birga davom etadi | ha, har bosqichda | hisob-kitob bosqichlari: hamma tugatmaguncha keyingisi boshlanmaydi |
Semaphore | N ta ruxsat: acquire() oladi, ruxsat qolmagan boʻlsa kutadi; release() qaytaradi | ha | tashqi servisga bir vaqtda 10 tadan koʻp soʻrov yubormaslik |
Phaser | barrier kabi, lekin ishtirokchilar soni ish davomida oʻzgarishi mumkin | ha | ishtirokchilari qoʻshilib-chiqib turadigan bosqichli vazifa |
Tushunganingizni tekshiring
Nega wait() doim while siklida chaqiriladi?Javob
Chunki uygʻonish shart bajarilganini anglatmaydi. Thread notifysiz ham uygʻonishi mumkin — bu spurious wakeup, notifyAll hamma kutayotganlarni uygʻotadi, uygʻongan thread esa monitorni qayta olguncha boshqa thread shartni yana oʻzgartirib qoʻyishi mumkin. while uygʻongandan keyin shartni qayta tekshiradi.
if (item == null) wait(); bilan ikki consumer bitta element uchun uygʻonishi mumkin: birinchisi elementni oladi, ikkinchisi esa ifdan allaqachon oʻtgani uchun null bilan ishlaydi. while bilan ikkinchisi shartni qayta tekshiradi va yana kutishga ketadi.
wait va notify faqat oʻsha obyektning monitori ushlab turilganda chaqiriladi, aks holda IllegalMonitorStateException. Bu bejiz emas: shartni tekshirish va kutishga ketish bitta lock ostida boʻlmasa, notify ularning orasiga tushib, yoʻqolib ketishi mumkin — lost wakeup. notify hech narsani eslab qolmaydi: hech kim kutmayotganda chaqirilsa, izsiz ketadi.
BlockingQueue bilan producer-consumer qanday yoziladi va consumerʼlar qanday toʻxtatiladi?Javob
Producer put, consumer take qiladi: navbat toʻla boʻlsa put, boʻsh boʻlsa take kutadi, sinxronizatsiyani navbatning oʻzi qiladi. Toʻxtatish uchun koʻpincha poison pill yuboriladi — «ish tugadi» degan maxsus element: uni olgan consumer siklidan chiqadi.
Navbat cheklangan boʻlishi muhim. Producer consumerʼdan tez boʻlsa, cheksiz navbat xotirani toʻldirib yuboradi, cheklangan navbatda esa put producerʼni kutishga majbur qiladi.
Poison pill har bir consumer uchun bittadan yuboriladi: consumer oʻz pillʼini olib chiqib ketadi, qolganlar oʻzinikini oladi. U navbatda oddiy ishlardan keyin turgani uchun, oldin qoʻyilgan hamma ish bajariladi. Muqobil yoʻl — consumer threadʼlarni interrupt qilish: take InterruptedException tashlaydi, lekin navbatda qolgan ishlar bajarilmay qoladi.
Metodlar uch xil: put va take kutadi, offer va poll darhol false yoki null qaytaradi, offer(e, timeout, unit) va poll(timeout, unit) esa muddat bilan kutadi. null elementga ruxsat yoʻq: poll uchun null «navbat boʻsh» degan maʼnoni beradi.
record Job(String name) {}
static final Job POISON = new Job("stop");
void produce(BlockingQueue<Job> q, List<Job> jobs,
int consumers)
throws InterruptedException {
for (Job j : jobs) q.put(j);
for (int i = 0; i < consumers; i++) q.put(POISON);
}
void consume(BlockingQueue<Job> q)
throws InterruptedException {
while (true) {
Job j = q.take();
// == : aynan shu obyekt, equals emas
if (j == POISON) return;
process(j);
}
}CountDownLatch, CyclicBarrier va Semaphore qachon ishlatiladi?Javob
CountDownLatch — bir yoki bir nechta thread boshqalar N ta ishni tugatishini kutadi; bir martalik. CyclicBarrier — N ta thread bir nuqtada bir-birini kutadi va birga davom etadi; qayta ishlatiladi. Semaphore — bir vaqtda nechta thread resursdan foydalanishini cheklaydi.
Latch va barrier farqi — kim kimni kutishida. Latchʼda await qiladiganlar va countDown qiladiganlar har xil: worker countDown() qilib, kutmasdan ishini davom ettiradi. Barrierʼda esa hamma ishtirokchi await() qiladi va oxirgisi kelmaguncha hech kim oʻtmaydi. Latch nolga tushgach abadiy ochiq qoladi, barrier esa keyingi bosqich uchun qayta ishlatiladi.
Barrierʼda bitta ishtirokchi interrupt boʻlsa yoki muddati tugasa, barrier buziladi va qolganlar BrokenBarrierException oladi — hech kim abadiy osilib qolmaydi. Konstruktorga barrier action berish mumkin: u oxirgi ishtirokchi kelganda, hamma davom etishidan oldin bir marta bajariladi.
Semaphoreda ruxsatning egasi yoʻq: release()ni acquire() qilmagan thread ham chaqira oladi, shuning uchun acquire va release juftligi try/finallyda yoziladi. Virtual threadʼlar bilan resursni cheklashning toʻgʻri yoʻli ham pool emas, Semaphore.
CountDownLatch ready = new CountDownLatch(3);
for (int i = 0; i < 3; i++) {
pool.submit(() -> {
try {
warmUp();
} finally {
ready.countDown(); // xato boʻlsa ham
}
});
}
ready.await(); // uchalasi tugaguncha kutadi
Semaphore permits = new Semaphore(10);
permits.acquire();
try {
callExternalService();
} finally {
permits.release();
}5Thread pool, ExecutorService va Future
Har bir vazifa uchun yangi platform thread yaratish qimmat: OS thread yaratiladi, stack uchun joy band qilinadi, minglab thread esa xotira va schedulerʼni ogʻirlashtiradi. Thread pool bir nechta threadʼni ushlab turadi va ularga navbatdagi vazifalarni beradi. Javaʼda buning interfeysi — ExecutorService, asosiy implementationʼi — ThreadPoolExecutor.
Vazifa ikki xil boʻladi. Runnable natija qaytarmaydi va checked exception tashlay olmaydi. Callable<V> natija qaytaradi va istalgan exception tashlay oladi. submit() ikkalasini ham qabul qiladi va Future qaytaradi — hali tayyor boʻlmagan natijaga «chipta». future.get() natija tayyor boʻlguncha joriy threadʼni bloklaydi; vazifa exception tashlagan boʻlsa, get() uni ExecutionExceptionga oʻrab tashlaydi.
ThreadPoolExecutor yangi vazifani koʻpchilik kutganidan boshqacha tartibda qabul qiladi: avval core threadʼlar yaratiladi, keyin navbat toʻladi va faqat navbat toʻlgandan keyingina qoʻshimcha threadʼlar qoʻshiladi:
corePoolSize = 2, maximumPoolSize = 3, navbat — 2 joyli ArrayBlockingQueue. Vazifalar uzoq ishlaydi, hech biri hali tugamaydi.| Parametr | Maʼnosi |
|---|---|
corePoolSize | asosiy threadʼlar soni: yaratilgach, default holatda ishsiz qolsa ham yopilmaydi |
maximumPoolSize | navbat toʻlganda threadʼlar soni shu chegaragacha oshishi mumkin |
keepAliveTime | core dan ortiq thread shuncha vaqt ishsiz tursa, yopiladi |
workQueue | core threadʼlar band boʻlganda vazifalar kutadigan navbat |
RejectedExecutionHandler | navbat ham, threadʼlar ham toʻla boʻlganda nima qilish; default AbortPolicy RejectedExecutionException tashlaydi |
Executors fabrikalari qulay, lekin ular qanday pool yaratishini bilish kerak. newFixedThreadPool(n) cheksiz LinkedBlockingQueue ishlatadi: vazifalar ishlov berilishidan tez kelsa, navbat xotirani toʻldiradi va OutOfMemoryErrorgacha hech qanday signal bermaydi. newCachedThreadPool() SynchronousQueue bilan, yaʼni navbatsiz ishlaydi va threadʼlar sonini cheklamaydi: yuk oshsa, minglab thread yaratadi. Shuning uchun productionʼda ThreadPoolExecutor koʻpincha cheklangan navbat va aniq rejection policy bilan yaratiladi.
Pool oʻlchami vazifa turiga bogʻliq. CPU-bound vazifalar — hisob-kitob — uchun yadrolar soniga yaqin oʻlcham yetarli: undan koʻp thread faqat context switchʼni koʻpaytiradi. IO-bound vazifalar — HTTP, maʼlumotlar bazasi — vaqtining koʻp qismini kutishda oʻtkazadi, ular uchun taxminiy formula: threadʼlar = yadrolar × (1 + kutish vaqti / hisoblash vaqti). Masalan, 8 yadro va vaqtning 90 foizi kutish boʻlsa — taxminan 80 thread. Bu boshlangʻich nuqta: haqiqiy oʻlcham yuk ostida oʻlchab tanlanadi.
Pool oʻzi yopilmaydi. newFixedThreadPool va newSingleThreadExecutor threadʼlari non-daemon: shutdown() chaqirilmasa, main tugasa ham JVM ishlab turaveradi. newCachedThreadPool threadʼlari 60 soniya ishsiz turgach yopiladi, newWorkStealingPool va virtual threadʼlar esa daemon.
Tushunganingizni tekshiring
Callable va Runnable farqi nima? future.get() nega bloklaydi va vazifadagi exception qayerga ketadi?Javob
Callable natija qaytaradi va checked exception tashlay oladi, Runnable — yoʻq. get() natija hali tayyor boʻlmasa, uni kutadi: qaytaradigan narsa hali yoʻq. Vazifadagi exception Futureda saqlanadi va get() uni ExecutionExceptionga oʻrab tashlaydi.
get() uch xil exception tashlaydi: ExecutionException — vazifa xato bilan tugadi, asl sabab getCause()da; CancellationException — vazifa bekor qilingan; InterruptedException — kutayotgan threadʼning oʻzi interrupt qilindi. get(timeout, unit) muddat tugasa TimeoutException tashlaydi, lekin vazifani toʻxtatmaydi — buning uchun future.cancel(true) chaqiriladi, u vazifa bajarilayotgan threadʼni interrupt qiladi.
Tuzoq: submit() bilan berilgan vazifaning exceptionʼi kimdir get() chaqirmaguncha hech qayerda koʻrinmaydi. Natijasi kerak boʻlmagan vazifani submit qilib, Futureni tashlab yuborsangiz, xato jimgina yoʻqoladi. execute(Runnable) esa exceptionʼni threadʼning UncaughtExceptionHandleriga beradi, default holatda u stack traceʼni chiqaradi.
get() bilan kutish chaqiruvchi threadʼni band qiladi. Bir nechta natijani birlashtirish yoki bloklamasdan davom etish kerak boʻlsa, CompletableFuture qulayroq — keyingi boʻlimda.
ExecutorService pool = Executors.newFixedThreadPool(4);
Future<Integer> f = pool.submit(() -> {
if (Math.random() < 0.5)
throw new IOException("tarmoq xatosi");
return 42;
});
try {
int result = f.get(2, TimeUnit.SECONDS);
} catch (ExecutionException e) {
Throwable cause = e.getCause(); // IOException
} catch (TimeoutException e) {
// vazifa threadʼini interrupt qiladi
f.cancel(true);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}Thread poolʼni qanday toʻgʻri yopish kerak? shutdown() va shutdownNow() farqi nima?Javob
shutdown() yangi vazifalarni qabul qilmaydi, lekin navbatdagilarni ham bajaradi va darhol qaytadi. shutdownNow() navbatni boʻshatadi — bajarilmagan vazifalar roʻyxatini qaytaradi — va ishlayotgan threadʼlarni interrupt qiladi. Ikkalasi ham tugashni kutmaydi: buning uchun awaitTermination bor.
Odatiy tartib: shutdown(), keyin awaitTermination bilan maʼlum vaqt kutish, vaqt yetmasa — shutdownNow(). shutdownNow() ham kafolat emas: interruptʼga javob bermaydigan vazifa ishlashda davom etadi.
Yopilmagan pool JVMʼni ushlab turishi mumkin: newFixedThreadPool va newSingleThreadExecutor threadʼlari non-daemon, main tugasa ham dastur chiqmaydi. shutdowndan keyin berilgan vazifa rad etiladi — default holatda RejectedExecutionException.
Java 19 dan beri ExecutorService AutoCloseable: close() shutdown() qiladi va hamma vazifalar tugashini kutadi, kutish paytida interrupt boʻlsa — shutdownNow(). Shuning uchun Java 21 da qisqa umrli pool try-with-resources bilan yoziladi.
pool.shutdown();
try {
if (!pool.awaitTermination(30, TimeUnit.SECONDS)) {
pool.shutdownNow();
}
} catch (InterruptedException e) {
pool.shutdownNow();
Thread.currentThread().interrupt();
}
// Java 19+: close() hamma vazifa tugashini kutadi
try (var exec = Executors.newFixedThreadPool(4)) {
exec.submit(this::importUsers);
exec.submit(this::importOrders);
}ThreadPoolExecutorga yangi vazifa kelganda nima boʻladi? Navbat toʻlsa-chi?Javob
Threadʼlar corePoolSizedan kam boʻlsa, yangi thread yaratiladi. Aks holda vazifa navbatga qoʻyiladi. Navbat toʻla boʻlsa va threadʼlar maximumPoolSizedan kam boʻlsa, yana thread yaratiladi. Hammasi toʻla boʻlsa, vazifa rad etiladi va RejectedExecutionHandler chaqiriladi.
Notoʻgʻri tasavvur: «yuk oshsa, pool avval threadʼlarni maximumʼgacha koʻpaytiradi». Aslida navbat birinchi toʻladi. Shuning uchun cheksiz navbat bilan maximumPoolSize hech qachon ishlamaydi: navbat toʻlmaydi va thread soni doim corePoolSizeda qoladi. Yana bir nozik joy: threadʼlar core sonidan kam boʻlsa, boshqalari boʻsh tursa ham yangi thread yaratiladi.
Toʻrtta tayyor rejection policy bor. Default — AbortPolicy: RejectedExecutionException tashlaydi. CallerRunsPolicy — vazifani execute()ni chaqirgan threadʼning oʻzi bajaradi, bu esa vazifa yuborishni tabiiy sekinlashtiradi. DiscardPolicy — jimgina tashlab yuboradi. DiscardOldestPolicy — navbatdagi eng eski vazifani tashlab, yangisini qoʻyadi. Oxirgi ikkitasi maʼlumot yoʻqotadi va faqat bu ongli qaror boʻlsa ishlatiladi.
Cheksiz navbatning xavfi — muammo yashirinadi: pool ulgurmayotganini hech narsa bildirmaydi, navbat esa million vazifagacha oʻsib, xotirani toʻldiradi. Cheklangan navbat va rejection esa tizim yukni koʻtara olmayotganini erta va aniq koʻrsatadi.
ThreadPoolExecutor pool = new ThreadPoolExecutor(
4, 16, // core, max
60, TimeUnit.SECONDS, // keepAlive
new ArrayBlockingQueue<>(1000),
new ThreadPoolExecutor.CallerRunsPolicy());6CompletableFuture va ForkJoinPool
Oddiy Futureda natija tayyor boʻlganda chaqiriladigan callback yoʻq: natija get() bilan kutiladi. CompletableFuture (Java 8) esa natija tayyor boʻlganda nima qilishni oldindan aytishga imkon beradi: bosqichlar zanjiri quriladi va hech bir thread natijani kutib bekor turmaydi.
CompletableFuture<Report> report = CompletableFuture
.supplyAsync(() -> loadUser(id), io)
.thenCompose(u -> loadOrdersAsync(u))
.thenApply(orders -> buildReport(orders))
.orTimeout(3, TimeUnit.SECONDS)
.exceptionally(ex -> Report.empty());| Metod | Nima qiladi |
|---|---|
supplyAsync(s, executor) | vazifani executorʼda boshlaydi; executor berilmasa — ForkJoinPool.commonPool()da |
thenApply(f) | natijani oddiy funksiya bilan oʻzgartiradi: T → U |
thenCompose(f) | natija bilan yangi asinxron vazifa boshlaydi: T → CompletableFuture<U>, ichma-ich Future hosil boʻlmaydi |
thenCombine(other, f) | ikki mustaqil vazifa natijasini birlashtiradi |
allOf(...), anyOf(...) | hammasi yoki birortasi tugaganda tugaydigan yangi CompletableFuture |
exceptionally(f) | faqat xato boʻlganda chaqiriladi va zaxira natija beradi |
handle(f) | har doim chaqiriladi: natija yoki exception bilan |
orTimeout, completeOnTimeout | muddat qoʻyadi (Java 9+) |
thenApplyAsync kabi ...Async variantlar bosqichni executorʼga beradi. Oddiy variant esa bosqichni odatda oldingi bosqichni tugatgan threadʼda bajaradi, oldingi bosqich allaqachon tugagan boʻlsa — chaqiruvchi threadʼning oʻzida.
Executor berilmasa, async bosqichlar ForkJoinPool.commonPool()ga tushadi. Bu — butun JVM uchun bitta umumiy pool: uni parallel streamʼlar, Arrays.parallelSort va boshqa kutubxonalar ham ishlatadi. Uning oʻlchami default holatda yadrolar sonidan bitta kam.
ForkJoinPool oddiy thread poolʼdan boshqacha tuzilgan: har bir worker threadʼning oʻz navbati — deque — bor. Vazifa fork bilan boʻlinganda qismlar oʻsha workerʼning navbatiga tushadi va worker ularni oxiridan oladi. Navbati boʻshab qolgan worker boshqa workerʼning navbatining boshidan vazifa «oʻgʻirlaydi» — bu work stealing. Shunda rekursiv boʻlinadigan hisob-kitobda hamma yadro band boʻladi, workerʼlar esa bitta umumiy navbat uchun kurashmaydi.
Bu tuzilish hisob-kitob uchun moʻljallangan, shuning uchun commonPoolʼga bloklovchi vazifa — HTTP, JDBC, Thread.sleep — berish xavfli: bir nechta shunday vazifa hamma workerʼni band qiladi: executorʼsiz yozilgan async bosqichlar navbatda turib qoladi, parallel streamʼlar esa faqat chaqiruvchi threadʼda, parallelliksiz ishlaydi — CPU deyarli boʻsh boʻlsa ham. IO vazifalar uchun doim alohida executor beriladi.
Tushunganingizni tekshiring
thenApply va thenCompose farqi nima? Bir nechta vazifani qanday parallel birlashtirasiz?Javob
thenApply natijani oddiy funksiya bilan oʻzgartiradi (T → U), Stream.mapga oʻxshab. thenCompose esa natija bilan yangi asinxron vazifa boshlaydigan funksiyani oladi (T → CompletableFuture<U>) va natijani tekislaydi, flatMapga oʻxshab. Mustaqil vazifalar avval boshlanadi, keyin thenCombine yoki allOf bilan birlashtiriladi.
Asinxron metodni thenApplyga bersangiz, CompletableFuture<CompletableFuture<Orders>> hosil boʻladi — ichma-ich Future. Uni ochish uchun yana join() kerak boʻladi, bu esa threadʼni bloklaydi. thenCompose buni bitta CompletableFuture<Orders>ga aylantiradi.
thenCompose zanjiri vazifalarni ketma-ket bajaradi: keyingisi oldingisining natijasi bilan boshlanadi. Vazifalar bir-biriga bogʻliq boʻlmasa, bu bekorga vaqt yoʻqotish. Ikkalasini avval boshlab, keyin thenCombine bilan birlashtirilsa, ular parallel ishlaydi. Koʻp vazifa uchun allOf bor: u CompletableFuture<Void> qaytaradi, natijalar esa har bir Futuredan join() bilan olinadi — allOf tugagach ular allaqachon tayyor va join() kutmaydi.
CompletableFuture<User> user =
supplyAsync(() -> loadUser(id), io);
CompletableFuture<List<Order>> orders =
supplyAsync(() -> loadOrders(id), io);
// ikkalasi parallel ishlaydi
CompletableFuture<Page> page =
user.thenCombine(orders, Page::new);
List<CompletableFuture<Price>> prices = ids.stream()
.map(i -> supplyAsync(() -> price(i), io))
.toList();
CompletableFuture<List<Price>> all = CompletableFuture
.allOf(prices.toArray(CompletableFuture[]::new))
.thenApply(v -> prices.stream()
.map(CompletableFuture::join)
.toList());CompletableFutureda xatolar qanday ushlanadi? exceptionally, handle va whenComplete farqi nima?Javob
Bosqichda exception chiqsa, keyingi bosqichlar oʻtkazib yuboriladi va xato zanjir boʻylab birinchi xato ishlovchisigacha boradi. exceptionally faqat xatoda chaqiriladi va zaxira qiymat beradi, handle har doim chaqiriladi va natijani yoki exceptionʼni oladi, whenComplete esa natijani oʻzgartirmaydi — log yozish kabi qoʻshimcha ish uchun.
Exception koʻpincha CompletionExceptionga oʻralgan holda keladi, asl sabab getCause()da: masalan, supplyAsync ichida tashlangan exception shunday oʻraladi. orTimeout qoʻygan TimeoutException esa oʻsha CompletableFuturening oʻzida oʻralmagan turadi, keyingi bosqichlarga esa CompletionException ichida oʻtadi. join() ham CompletionException, get() esa ExecutionException tashlaydi. Shuning uchun xato ishlovchisida sabab ochib tekshiriladi.
Xatoni hech kim ushlamasa, u CompletableFutureda qoladi va hech qayerda koʻrinmaydi — oddiy Futuredagi kabi. Natijasi join() qilinmaydigan vazifalarda zanjir oxiriga whenComplete bilan log qoʻyiladi.
cancel(true) ishlab turgan vazifani toʻxtatmaydi: CompletableFuture interrupt ishlatmaydi, u faqat natijani CancellationException bilan yakunlaydi, vazifa esa oxirigacha ishlayveradi.
CompletableFuture<Price> price = CompletableFuture
.supplyAsync(() -> remotePrice(id), io)
.orTimeout(2, TimeUnit.SECONDS)
.exceptionally(ex -> {
Throwable cause =
ex instanceof CompletionException ce
? ce.getCause() : ex;
log.warn("narx olinmadi", cause);
return Price.cached(id);
});supplyAsync executorʼsiz chaqirilsa, vazifa qayerda bajariladi? Nega unga bloklovchi vazifa berib boʻlmaydi?Javob
ForkJoinPool.commonPool()da — butun JVM uchun bitta, default holatda yadrolar sonidan bitta kam threadʼli pool. Uni parallel streamʼlar va boshqa kutubxonalar ham ishlatadi. Bloklovchi vazifalar uning hamma workerʼlarini band qiladi: executorʼsiz yozilgan async bosqichlar navbatda turib qoladi, parallel streamʼlar esa faqat chaqiruvchi threadʼda, parallelliksiz ishlaydi.
commonPool hisob-kitob uchun moʻljallangan: worker hech qachon tashqi javobni kutmaydi, deb hisoblanadi. 8 yadroli serverda unda 7 ta worker bor. 7 ta CompletableFuture HTTP javobini 2 soniya kutsa, shu 2 soniya davomida executorʼsiz yozilgan async bosqichlar navbatda turib qoladi, parallel streamʼlar esa faqat chaqiruvchi threadʼda, parallelliksiz ishlaydi — CPU deyarli boʻsh boʻlsa ham.
Pool oddiy bloklovchi chaqiruvlar uchun yangi thread qoʻshmaydi. Faqat ForkJoinPool.managedBlock orqali kutish — masalan, commonPool workerʼi ichida chaqirilgan CompletableFuture.join() yoki get() — poolʼga vaqtincha qoʻshimcha worker qoʻshishi mumkin. JDKʼning HttpClient.send() ham ichida shunday kutadi; JDBC drayveri, HttpURLConnection va socketdan oʻzi oʻqiydigan kutubxonalar esa yoʻq.
Qoida: IO vazifalarga doim alohida executor beriladi — supplyAsync(task, ioExecutor). Yana bir nozik joy: konteynerga 1 yoki 2 CPU berilgan boʻlsa, commonPool parallelism 1 boʻladi va CompletableFuture executorʼsiz chaqirilgan har bir async vazifa uchun yangi thread yaratadi.
Work stealing qanday ishlaydi va nima uchun kerak?Javob
ForkJoinPoolda har bir workerʼning oʻz deque navbati bor. Worker oʻz vazifalarini navbatning bir uchidan oladi, ishsiz qolgan worker esa boshqa workerʼning navbatining ikkinchi uchidan vazifa «oʻgʻirlaydi». Shunday qilib yuk avtomatik taqsimlanadi va workerʼlar bitta umumiy navbat uchun kurashmaydi.
Bu fork/join vazifalari uchun moʻljallangan: RecursiveTask katta ishni fork bilan ikkiga boʻladi, qismlar oʻz navbatiga tushadi, natija join bilan yigʻiladi. Worker eng oxirgi qoʻshilgan, yaʼni eng kichik qismni oladi — u hali cacheʼda. Oʻgʻri esa navbatning boshidan eng eski, yaʼni eng katta qismni oladi: bitta oʻgʻirlash bilan koʻp ish oladi va egasi bilan navbatning har xil uchida ishlaydi.
join() oddiy kutish emas: natija tayyor boʻlmasa, worker bekor turmaydi, shu orada boshqa vazifalarni bajaradi. Shuning uchun ForkJoinPoolda rekursiv boʻlinadigan vazifalar thread starvationʼga olib kelmaydi, oddiy ThreadPoolExecutorda esa xuddi shunday kod deadlockʼga tushishi mumkin.
Ish juda mayda boʻlaklarga boʻlinsa, vazifa yaratish xarajati foydadan oshib ketadi. Shuning uchun boʻlak maʼlum chegaradan kichik boʻlganda u oddiy sikl bilan hisoblanadi.
class SumTask extends RecursiveTask<Long> {
private final long[] a;
private final int from, to;
SumTask(long[] a, int from, int to) {
this.a = a; this.from = from; this.to = to;
}
@Override
protected Long compute() {
if (to - from <= 10_000) {
long s = 0;
for (int i = from; i < to; i++) s += a[i];
return s;
}
int mid = (from + to) >>> 1;
SumTask left = new SumTask(a, from, mid);
// oʻz navbatiga; oʻgʻirlanishi mumkin
left.fork();
long right = new SumTask(a, mid, to).compute();
return right + left.join();
}
}7ReentrantLock, atomic klasslar va CAS
java.util.concurrent.locks paketi synchronizedga moslashuvchan muqobil beradi. ReentrantLock monitor kabi reentrant va xuddi shunday visibility kafolatini beradi, lekin qoʻshimcha imkoniyatlari bor: tryLock lockʼni kutmasdan yoki muddat bilan olishga urinadi, lockInterruptibly bilan kutish interruptʼga javob beradi, fair rejim va bitta lock uchun bir nechta Condition. Evaziga lockʼni finallyda oʻzingiz boʻshatishingiz shart.
private final ReentrantLock lock = new ReentrantLock();
boolean tryPay(long sum) throws InterruptedException {
if (!lock.tryLock(100, TimeUnit.MILLISECONDS)) {
return false; // band: keyinroq urinamiz
}
try {
balance -= sum;
return true;
} finally {
lock.unlock();
}
}ReadWriteLock oʻqish va yozishni ajratadi: bir vaqtda koʻp thread oʻqiy oladi, yozuvchi esa yolgʻiz ishlaydi. StampedLock (Java 8) bundan ham yengilroq optimistic oʻqishni beradi — lock olmasdan oʻqib, keyin oraliqda yozuv boʻlmaganini tekshirish — lekin u reentrant emas.
Lockʼsiz yondashuvning asosi — CAS, compare-and-set: «qiymat hali ham A boʻlsa, uni B ga almashtir» degan, protsessor atomik bajaradigan amal (x86ʼda lock cmpxchg). U muvaffaqiyatsiz boʻlsa, thread bloklanmaydi: yangi qiymatni oʻqib, qayta urinadi. AtomicInteger, AtomicLong, AtomicReference shu asosda ishlaydi, ConcurrentHashMap ham boʻsh bucketga CAS bilan yozadi.
AtomicInteger max = new AtomicInteger();
void offer(int x) {
int cur;
do {
cur = max.get();
if (x <= cur) return;
} while (!max.compareAndSet(cur, x));
}
// xuddi shu sikl tayyor holda
max.accumulateAndGet(x, Math::max);Lock-free kod past contentionʼda juda tez, lekin koʻp thread bitta oʻzgaruvchiga yopirilsa, ular CASʼni qayta-qayta yutqazadi. Koʻp yoziladigan hisoblagichlar uchun LongAdder (Java 8) bor: u yozuvlarni bir nechta katakka taqsimlaydi, sum() esa ularni qoʻshib beradi.
Tushunganingizni tekshiring
ReentrantLock va synchronized farqi nima? Qachon qaysi birini tanlaysiz?Javob
Ikkalasi ham reentrant lock va bir xil visibility kafolatini beradi. ReentrantLockda qoʻshimcha imkoniyatlar bor: tryLock — kutmasdan yoki muddat bilan, lockInterruptibly, fair rejim va bir nechta Condition. synchronized esa soddaroq: lock blokdan chiqishda oʻzi boʻshaydi. Bu imkoniyatlar kerak boʻlmasa — synchronized.
ReentrantLockda unlock()ni finallyda chaqirish sizning zimmangizda: unutilsa yoki exception yoʻlida qolib ketsa, lock abadiy band boʻladi. synchronizedda bunday xato boʻlmaydi.
Fair lock kutayotgan threadʼlarga navbat bilan beriladi, starvation boʻlmaydi, lekin throughput ancha past: har safar navbatdagi threadʼni uygʻotish kerak. Default, unfair lockʼni esa hozirgina kelgan thread navbatsiz egallashi mumkin — bu tezroq. Qiziq tomoni: muddatsiz tryLock() fair lockʼda ham navbatni buzadi; fairnessʼni saqlash uchun tryLock(0, TimeUnit.SECONDS) ishlatiladi.
Java 21–23 da yana bir sabab bor: virtual thread synchronized ichida bloklansa, carrier threadʼni ham band qiladi — pinning, ReentrantLock esa yoʻq. Java 24 da bu tuzatildi (JEP 491), demak 25 LTS da tanlov faqat kerakli imkoniyatlarga qarab qilinadi.
AtomicInteger lockʼsiz qanday ishlaydi? ABA muammosi nima?Javob
CAS orqali: compareAndSet(expected, next) qiymat hali ham expected boʻlsa, uni nextga almashtiradi, aks holda false qaytaradi — bu protsessor atomik bajaradigan amal (x86ʼda lock cmpxchg). Yutqazgan thread bloklanmaydi, yangi qiymatni oʻqib qayta urinadi. ABA — qiymat A → B → A boʻlib oʻzgarganda CAS buni sezmaydi va hech narsa oʻzgarmagan deb hisoblaydi.
incrementAndGet() mantiqan sikl: joriy qiymatni oʻqish, +1 hisoblash, CAS; boshqa thread oldin ulgursa — qaytadan. Koʻp protsessorlarda JIT uni bitta atomik instruksiyaga aylantiradi, masalan x86ʼda lock xadd. Lock yoʻqligi uchun deadlock ham, threadʼni uxlatib-uygʻotish xarajati ham yoʻq.
ABA qachon muhim: CAS faqat qiymatni solishtiradi, tarixini emas. Lock-free stackʼda thread tepadagi A nodeʼni koʻrib, headni A.nextga, yaʼni B ga almashtirmoqchi. Shu orada boshqa threadʼlar A ni, keyin B ni oladi va A ni qaytarib qoʻyadi. CAS muvaffaqiyatli oʻtadi — head yana A — va head endi stackʼda yoʻq B ga koʻrsatadi: stack buzildi.
Javaʼda bu faqat xuddi shu obyekt qayta ishlatilganda boʻladi: GC hali kimdir ushlab turgan nodeʼni yangi node sifatida qaytarib bermaydi, CAS esa referenceʼlarni solishtiradi. Lekin obyektlar pool qilinsa yoki qiymat oddiy son boʻlsa, muammo real. Yechim — qiymatga versiya qoʻshish: AtomicStampedReference reference bilan birga int stamp saqlaydi va CAS ikkalasini birga solishtiradi.
8Virtual threadʼlar, ThreadLocal va structured concurrency
Platform thread qimmat, shuning uchun serverlar pool ishlatadi va bir vaqtdagi soʻrovlar soni threadʼlar soni bilan cheklanadi. Soʻrov vaqtining koʻp qismini maʼlumotlar bazasi yoki HTTP javobini kutishga sarflasa, threadʼlar bekor turadi, CPU esa boʻsh. Virtual threadʼlar — Java 21 da final (JEP 444), 19 va 20 da preview — bu cheklovni olib tashlaydi: ular OS threadʼi emas, JVM boshqaradigan yengil obyektlar, ularni millionlab yaratish mumkin.
Virtual thread kod bajarish uchun platform threadʼga — carrier threadʼga — mount qilinadi. U bloklovchi amalga yetganda — socketdan oʻqish, sleep, BlockingQueue.take, ReentrantLock — JVM uning stack frameʼlarini heapʼga koʻchiradi va carrierʼni boʻshatadi: bu unmount. Amal tayyor boʻlgach, virtual thread yana navbatga qoʻyiladi va istalgan boʻsh carrierʼda davom etadi:
Carrierʼlar — alohida ForkJoinPool, default holatda yadrolar soniga teng. Kod oʻzgarmaydi: xuddi oʻsha bloklovchi API, lekin bloklanish OS threadʼini emas, faqat virtual threadʼni toʻxtatadi.
try (ExecutorService exec =
Executors.newVirtualThreadPerTaskExecutor()) {
for (Request r : requests) {
// har vazifaga yangi virtual thread
exec.submit(() -> handle(r));
}
} // close() hammasi tugashini kutadi
Thread.ofVirtual().name("vt-", 0).start(task);Pinning — virtual thread carrierʼdan tusha olmaydigan holat. Java 21–23 da bu synchronized blok yoki metod ichida, shu jumladan Object.wait()da, hamda native metod yoki foreign function chaqiruvi davomida boʻladi. Pinned virtual thread bloklansa, carrier ham bloklanadi. Object.wait()da scheduler vaqtincha qoʻshimcha carrier yaratib qoplaydi, synchronized ichidagi IO va monitor kutishni esa qoplamaydi. Java 24 dan (JEP 491), demak 25 LTS da ham, synchronized endi pin qilmaydi.
ThreadLocal har bir thread uchun alohida qiymat saqlaydi. Qiymat aslida ThreadLocal obyektida emas, threadʼning oʻzida turadi: har bir Threadda ThreadLocalMap bor, uning kaliti — ThreadLocal obyektiga weak reference, qiymati esa oddiy, strong reference. Shuning uchun qiymat thread yashagancha yashaydi — thread poolʼda bu xavfli.
Virtual threadʼlar ThreadLocalni qoʻllab-quvvatlaydi, lekin millionta thread — millionta nusxa. ScopedValue — Java 25 da final (JEP 506), 21–24 da preview — boshqacha yondashuv: qiymat faqat bitta blok davomida bogʻlanadi, uni oʻzgartirib boʻlmaydi va blok tugashi bilan u oʻzi yoʻqoladi.
static final ScopedValue<User> USER =
ScopedValue.newInstance();
void handle(Request req) {
ScopedValue.where(USER, auth(req))
.run(() -> service.process(req));
}
// chuqurroqdagi istalgan metodda
User u = USER.get();Structured concurrency bir vazifaning parallel qismlarini bitta birlik sifatida boshqaradi: qismlar bitta blokda boshlanadi va blokdan chiqishdan oldin hammasi tugaydi; biri xato bersa, qolganlari bekor qilinadi. StructuredTaskScope hali preview API: Java 19–20 da incubator, Java 21 da birinchi preview (JEP 453), Java 25 da API sezilarli oʻzgardi (JEP 505), 26 va 27 da ham preview davom etmoqda.
Tushunganingizni tekshiring
Virtual thread qanday ishlaydi va qachon foyda beradi?Javob
Virtual thread — JVM boshqaradigan yengil thread. U carrier deb ataladigan platform threadʼda bajariladi va bloklovchi amalda carrierʼdan tushadi: stackʼi heapʼda saqlanadi, carrier esa boshqa virtual threadʼni oladi. Foyda koʻp kutadigan, IO-bound vazifalarda: bir vaqtda minglab soʻrov oz sonli OS threadʼida ishlaydi.
Virtual threadʼning stackʼi heapʼda stack chunk obyektlari sifatida saqlanadi va kerakicha oʻsib-qisqaradi: u faqat haqiqatan ishlatilgan frameʼlar uchun joy oladi. Yaratish va almashtirish OS ishtirokisiz boʻladi, shuning uchun virtual thread yaratish oddiy obyekt yaratishga yaqin.
Throughput oshadi, bitta soʻrovning tezligi emas. Soʻrov 100 ms maʼlumotlar bazasini kutsa, virtual threadʼda ham 100 ms kutadi — faqat shu vaqtda OS threadʼi boshqa ishni bajaradi. CPU-bound vazifada esa foyda yoʻq: carrierʼlar yadrolar soniga teng, ish baribir CPU vaqtini talab qiladi. Scheduler time slicing qilmaydi, shuning uchun uzoq hisob-kitob carrierʼni oxirigacha band qiladi.
Toʻgʻri foydalanish: har vazifaga yangi virtual thread (newVirtualThreadPerTaskExecutor()), pool qilmaslik; cheklash kerak boʻlsa — Semaphore; ThreadLocalda katta obyektlarni keshlamaslik. Virtual threadʼlar doim daemon, ularning prioritetini oʻzgartirib boʻlmaydi.
Pinning nima va u qachon muammo boʻladi?Javob
Pinning — virtual thread bloklanganda carrierʼdan tusha olmaydigan holat: bunda carrier, yaʼni OS threadʼi ham bloklanadi. Java 21–23 da bunga synchronized ichida bloklanish va native chaqiruvlar sabab boʻladi. Java 24 dan synchronized endi pin qilmaydi (JEP 491).
Sabab: Java 21 da monitor egasi carrier thread hisoblanardi. Virtual thread synchronized ichida carrierʼdan tushsa, shu carrierʼga chiqqan boshqa virtual thread monitor egasi boʻlib koʻrinib qolardi va mutual exclusion buzilardi. Shuning uchun JVM bunday paytda unmountʼga ruxsat bermaydi.
Pinningʼning oʻzi xato emas: qisqa synchronized blok hech narsani buzmaydi. Muammo — pinned holatda uzoq bloklanish, masalan synchronized ichida HTTP yoki JDBC chaqiruvi. Bunday threadʼlar carrierʼlar sonicha boʻlsa, masalan 8 ta, qolgan hamma virtual threadʼlar navbatda qotib qoladi: CPU boʻsh, ilova javob bermaydi. Scheduler bunday pinningni qoʻshimcha carrier bilan qoplamaydi.
Topish: JFR jdk.VirtualThreadPinned eventʼi — default holatda yoqilgan, 20 ms dan uzun pinningni yozadi; Java 21–23 da -Djdk.tracePinnedThreads=full ham bor, Java 24 da u olib tashlangan. Java 21 da yechim — uzoq bloklanadigan synchronized joylarni ReentrantLockga almashtirish yoki Java 24+ ga oʻtish.
ThreadLocal qanday ishlaydi va thread poolʼda qanday xavfi bor?Javob
Har bir Threadda ThreadLocalMap bor: ThreadLocal — kalit, qiymat esa shu threadʼga tegishli. Poolʼda thread vazifadan keyin yopilmaydi, shuning uchun remove() qilinmagan qiymat keyingi vazifaga oʻtadi va xotirada qolib ketadi. Qiymat finally ichida tozalanadi.
get() Thread.currentThread()ning mapʼidan shu ThreadLocal boʻyicha qiymatni oladi, shuning uchun lock kerak emas: har thread faqat oʻz mapʼiga tegadi. Kalit weak reference: ThreadLocal obyektiga hech kim murojaat qilmay qolsa, kalit GC boʻladi. Qiymat esa strong — u mapʼdagi keyingi tozalashgacha yoki thread oʻlguncha qoladi.
Poolʼda ikki xil xato chiqadi. Maʼlumot oqib oʻtadi: filter CURRENT.set(user) qildi, remove() qilmadi — xuddi shu threadʼga tushgan keyingi soʻrov oldingi foydalanuvchini koʻradi. Memory leak: thread oylab yashaydi va qiymatni ushlab turadi; ilova serverida bu qiymat ilovaning klass loaderʼini ham ushlab qolishi mumkin, shunda qayta deploydan keyin eski ilova xotiradan ketmaydi.
InheritableThreadLocal qiymatni thread yaratilgan paytda bola threadʼga koʻchiradi. Lekin poolʼdagi thread bir marta yaratiladi, shuning uchun keyingi vazifalar yangi qiymatni olmaydi — bu ham koʻp uchraydigan xato.
static final ThreadLocal<User> CURRENT =
new ThreadLocal<>();
void handle(Request req) {
CURRENT.set(auth(req));
try {
service.process(req);
} finally {
CURRENT.remove(); // poolʼga toza qaytadi
}
}Structured concurrency nima beradi? StructuredTaskScope bilan parallel chaqiruv qanday yoziladi?Javob
Bir vazifaning parallel qismlari bitta blokda boshlanadi va blokdan chiqishdan oldin hammasi tugaydi. Qism xato bersa, qolganlari avtomatik bekor qilinadi; asosiy thread interrupt boʻlsa ham. StructuredTaskScope hali preview: Java 21 dagi API Java 25 da oʻzgargan.
ExecutorService bilan ikki servisni parallel chaqirsangiz, birinchisi xato bersa, ikkinchisi baribir oxirigacha ishlaydi. get() bilan kutayotgan thread interrupt boʻlsa, vazifalar yetim qoladi — thread leak. StructuredTaskScope vazifalarni kod bloki bilan bogʻlaydi: try-with-resources tugaganda hamma bola vazifalar tugagan yoki bekor qilingan boʻladi, yangi formatdagi thread dumpʼda esa ular ota vazifa ostida koʻrinadi. fork default holatda har bir qism uchun yangi virtual thread yaratadi.
Java 21–24: new StructuredTaskScope.ShutdownOnFailure() — biri xato bersa, qolganlarini bekor qiladi; ShutdownOnSuccess — birinchi muvaffaqiyatli natijani olib, qolganlarini bekor qiladi. join() hammasini kutadi, throwIfFailed() xatoni ExecutionException bilan tashlaydi.
Java 25 (JEP 505): konstruktorlar oʻrniga StructuredTaskScope.open(), siyosat esa Joiner orqali beriladi, masalan Joiner.anySuccessfulResultOrThrow(). Parametrsiz open() — «biri xato bersa, hammasi bekor»; join() xato boʻlsa oʻzi FailedException tashlaydi. Java 26 (JEP 525) va 27 (JEP 533) da API yana oʻzgardi, masalan 27 da join() xatoni ExecutionException bilan tashlaydi. Shuning uchun preview kod JDK versiyasi bilan birga yangilanadi va --enable-preview bilan ishga tushiriladi.
// Java 21–24, --enable-preview
import java.util.concurrent.StructuredTaskScope.*;
Response handle(long id) throws Exception {
try (var scope = new ShutdownOnFailure()) {
Subtask<User> user =
scope.fork(() -> findUser(id));
Subtask<List<Order>> orders =
scope.fork(() -> findOrders(id));
scope.join().throwIfFailed();
return new Response(user.get(), orders.get());
}
}9Productionʼda muammoni topish: thread dump
Concurrency muammolari logʼda kamdan-kam aniq exception qoldiradi: ilova shunchaki sekinlashadi yoki javob bermay qoladi. Asosiy vosita — thread dump: shu lahzada har bir thread qayerda turgani, qaysi holatda ekani va qaysi lockʼni ushlab yoki kutib turgani.
| Buyruq | Nima beradi |
|---|---|
jcmd <pid> Thread.print | thread dump; -l bilan java.util.concurrent lockʼlari ham |
jstack <pid> | xuddi shu dump, eskiroq vosita; -l ham bor |
kill -3 <pid> | dumpni ilovaning stdoutʼiga chiqaradi (Linux, macOS) |
jcmd <pid> Thread.dump_to_file -format=json <fayl> | Java 21+: virtual threadʼlar bilan birga; oddiy dump ularni koʻrsatmaydi |
jcmd <pid> JFR.start | JFR yozuvi: jdk.JavaMonitorEnter va jdk.ThreadPark lock kutishlarini, jdk.VirtualThreadPinned esa pinningni vaqt bilan koʻrsatadi |
Bitta dump — bitta lahza: thread oʻsha paytda tasodifan lock kutayotgan boʻlishi mumkin. Shuning uchun 5–10 soniya oraliq bilan 3–5 ta dump olinadi, bir xil joyda qotib turgan threadʼlar muammoni koʻrsatadi. Har bir thread dumpʼda shunday koʻrinadi:
"transfer-1" #20 ... waiting for monitor entry
java.lang.Thread.State: BLOCKED (on object monitor)
at app.Bank.transfer(Bank.java:21)
- waiting to lock <0x…49a8> (a app.Account)
- locked <0x…4998> (a app.Account)
at app.Handler.run(Handler.java:14)| Dumpʼdagi belgi | Ehtimoliy sabab |
|---|---|
oxirida Found one Java-level deadlock | deadlock: JVM halqani oʻzi topadi va kim nimani ushlab, nimani kutayotganini koʻrsatadi |
koʻp thread BLOCKED, hammasida bir xil waiting to lock <0x…> | lock contention: shu lockʼni ushlab turgan, locked <0x…> qatori bor bitta thread lock ostida uzoq ish qilyapti |
koʻp thread WAITING (parking), bir xil parking to wait for <0x…> | xuddi shunday contention, lekin ReentrantLock kabi java.util.concurrent lockʼida |
poolʼning hamma threadʼlari bitta IO chaqiruvida RUNNABLE yoki Future.get()da WAITING | thread starvation: pool tashqi servisni yoki oʻz vazifalarini kutib band, navbat oʻsyapti |
Tushunganingizni tekshiring
Ilova qotib qoldi. Deadlockʼni qanday topasiz?Javob
Thread dump olinadi: jcmd <pid> Thread.print yoki jstack <pid>. Deadlock boʻlsa, JVM uni oʻzi topadi va dump oxiridagi Found one Java-level deadlock boʻlimida qaysi thread qaysi lockʼni ushlab, qaysi birini kutayotganini koʻrsatadi — synchronized uchun ham, ReentrantLock uchun ham.
Deadlockʼdagi threadʼlar synchronizedda BLOCKED, ReentrantLockda esa WAITING (parking) holatda turadi. synchronized uchun har birining stackʼida - locked <0x…> — ushlab turgani — va - waiting to lock <0x…> — kutayotgani — qatorlari bor: manzillarni solishtirib, halqani koʻrish mumkin. -l parametri har bir threadʼga Locked ownable synchronizers roʻyxatini qoʻshadi — ReentrantLock kabi lockʼlarni kim ushlab turgani shu yerda.
Dump faqat lahzani koʻrsatadi, lekin deadlock oʻz-oʻzidan tarqamaydi: keyingi dumpʼlarda ham xuddi shu threadʼlar xuddi shu joyda turadi. Kod ichidan ham tekshirish mumkin: ThreadMXBean.findDeadlockedThreads() — masalan, monitoring uchun.
Tuzatish — kodda: lock tartibini bir xil qilish, tryLock bilan muddat qoʻyish yoki ichma-ich lockʼlardan qochish. synchronized yoki lock() bilan yuz bergan deadlockʼdan chiqishning yagona yoʻli — ilovani qayta ishga tushirish.
Found one Java-level deadlock:
=============================
"transfer-1":
waiting to lock monitor 0x…ee0 (object 0x…49a8, a app.Account),
which is held by "transfer-2"
"transfer-2":
waiting to lock monitor 0x…fc0 (object 0x…4998, a app.Account),
which is held by "transfer-1"Lock contention va thread starvationʼni dumpʼda qanday ajratasiz?Javob
Contention — koʻp thread bitta lockʼni kutadi: ular BLOCKED yoki WAITING (parking) holatda va hammasi bir xil manzilni kutyapti, bitta thread esa shu lockʼni ushlab turibdi. Starvation — poolʼning hamma threadʼlari band, koʻpincha sekin IO yoki boshqa vazifani kutib, yangi vazifalar esa navbatda qoladi.
Contentionda birinchi navbatda lockʼni ushlab turgan thread qaraladi: u lock ostida nima qilyapti? Koʻpincha javob — lock ostida IO, katta kolleksiyani aylanib chiqish yoki log yozish. Belgilari: CPU toʻliq ishlatilmaydi, yadrolar qoʻshilsa ham throughput oshmaydi. JFR jdk.JavaMonitorEnter eventʼlari qaysi lock qancha kutilganini vaqt bilan koʻrsatadi.
Starvationda lock boʻlmasligi mumkin: pool threadʼlari RUNNABLE holatda socketdan oʻqiyapti yoki WAITING holatda Future.get()da turibdi, latency oʻsadi, CPU esa past. Klassik holatlar: tashqi servis sekinlashdi va hamma thread unga osilib qoldi; vazifa shu poolʼdagi boshqa vazifani get() bilan kutyapti — pool kichik boʻlsa, ichki vazifalar boʻsh thread topolmaydi va bu thread starvation deadlockʼga aylanadi; commonPool bloklovchi CompletableFutureʼlar bilan toʻlgan — hamma ForkJoinPool.commonPool-worker-* threadʼlari IO chaqiruvida.
Davolash: tashqi chaqiruvlarga timeout, har xil resurslar uchun alohida poollar, bogʻliq vazifalarni bloklamasdan birlashtirish, IO uchun alohida executor yoki virtual threadʼlar. Pool metrikalari — getActiveCount(), getQueue().size() — starvationʼni dumpʼdan oldin koʻrsatadi.
Tushunganingizni suhbatda sinab koʻring
Mavzuli mock intervyuda «Concurrency»ni tanlang. AI shu kabi savollarni beradi, javobingizga qarab chuqurroq savol soʻraydi va har javobingizga fikr bildiradi.