Java'da ko'p oqimli to'plamlar haqida nima deyish…

Java'dagi ko‘p oqimli kolleksiyalar bir vaqtning o‘zida bir nechta oqim bilan ishlash uchun xavfsiz usullarni taqdim etadi, bu esa raqobat shartlari va boshqa sinxronizatsiya muammolarining oldini oladi.

Asosiy interfeyslar va sinflar quyidagilarni o‘z ichiga oladi:

ConcurrentMap: Mapni kengaytiradi va atomik operatsiyalarni ta'minlaydi.
- ConcurrentHashMap: Yuqori unumdorlik uchun amalga oshirilgan, butun xaritani o‘zgartirish paytida bloklamaydi. To‘liq bloklamasdan oqim xavfsizligini ta'minlaydi.
CopyOnWriteArrayList va CopyOnWriteArraySet: Oqimga xavfsiz kolleksiyalar, ular har qanday o‘zgartirishda asosiy massivning nusxasini yaratadi. Ko‘p o‘qiladi va kam o‘zgartiriladigan kolleksiyalar uchun mos. O‘qish bloklamasdan amalga oshadi.
BlockingQueue: Kutish operatsiyalarini qo‘llab-quvvatlaydigan navbat interfeysi, masalan, navbat bo‘sh yoki to‘liq bo‘lsa, kutadi. Ish oqimini tashkil qilish uchun ishlatiladi, masalan, producer-consumer naqshida.
- ArrayBlockingQueue: Fiksir hajmli massiv asosidagi BlockingQueue amalga oshirilishi.
- LinkedBlockingQueue: Bog‘langan ro‘yxat asosidagi BlockingQueue amalga oshirilishi, ixtiyoriy hajm bilan.
- SynchronousQueue: Nol hajmli navbat. Har bir qo‘shish operatsiyasi mos keladigan chiqarish operatsiyasini kutadi va aksincha.
ConcurrentLinkedQueue: Bog‘langan ro‘yxat asosidagi oqimga xavfsiz Queue amalga oshirilishi. Bloklovchi operatsiyalarni qo‘llab-quvvatlamaydi.

Senkronlashtirilgan kolleksiyalardan (Collections.synchronizedList, Collections.synchronizedMap va boshqalar) farqi:

Senkron kolleksiyalar ob'ekt darajasida to‘liq bloklashni qo‘llaydi, bu yuqori raqobat sharoitida unumdorlikni kamaytirishi mumkin.
ConcurrentHashMap kabi ko‘p oqimli kolleksiyalar, yaxshiroq unumdorlik uchun, yanada granular bloklash yoki boshqa mexanizmlardan foydalanadi.
Senkron kolleksiyalarning iteratorlari, kolleksiya boshqa oqim tomonidan o‘zgartirilsa, ConcurrentModificationException xatosini chiqarishi mumkin. Ko‘p oqimli kolleksiyalarning iteratorlari odatda bunday o‘zgartirishlarga qarshi ko‘proq chidamli.

Maxsus foydalanish senariysi uchun: o‘qish/yazish tezligi, bloklovchi operatsiyalarga ehtiyoj, unumdorlik talablari va boshqalar asosida tanlanadi.

ConcurrentHashMapdan foydalanish misoli:

import java.util.concurrent.ConcurrentHashMap;

public class ConcurrentExample {

    private final ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

    public void updateValue(String key, Integer value) {
        map.put(key, value); // O‘qimga xavfsiz operatsiya
    }

    public Integer getValue(String key) {
        return map.get(key); // O‘qimga xavfsiz operatsiya
    }

    public void incrementValue(String key) {
        // Atomik operatsiya: agar kalit mavjud bo‘lmasa, 1 ni joylashtiradi, aks holda mavjud qiymatni oshiradi
        map.compute(key, (k, v) -> (v == null) ? 1 : v + 1);
    }
}

BlockingQueuedan foydalanish misoli:

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ArrayBlockingQueue;

public class ProducerConsumer {

    private final BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);

    // Ishlab chiqaruvchi
    public void produce(Integer item) throws InterruptedException {
        queue.put(item); // To‘ldirilgan bo‘lsa, bloklanadi
        System.out.println("Produced: " + item);
    }

    // Foydalanuvchi
    public Integer consume() throws InterruptedException {
        Integer item = queue.take(); // Bo‘sh bo‘lsa, bloklanadi
        System.out.println("Consumed: " + item);
        return item;
    }
}

Java'da ko'p oqimli to'plamlar haqida nima deyish mumkin?