Ko jūs varat pastāstīt par daudzprocesu kolekcijām…

Java daudzprocesu kolekcijas nodrošina drošus veidus darbam ar datiem vairākos straumos vienlaikus, novēršot sacensību stāvokļus un citas sinhronizācijas problēmas.

Galvenās saskarnes un klases ietver:

ConcurrentMap: paplašina Map, nodrošinot atomālas operācijas.
- ConcurrentHashMap: augstas veiktspējas realizācija, kas nebloku visu karti modificēšanas laikā. Nodrošina straumes drošību bez pilnīgas bloķēšanas.
CopyOnWriteArrayList un CopyOnWriteArraySet: straumes drošas kolekcijas, kas izveido kopiju galvenajam masīvam jebkurā modifikācijā. Labi piemēroti kolekcijām, kuras bieži tiek lasītas un reti mainītas. Lasīšana notiek bez bloķēšanas.
BlockingQueue: rindu saskarne, kas atbalsta gaidīšanas operācijas, kamēr rinda kļūst tukša vai pilna. Izmanto starpstraumes mijiedarbības organizēšanai, piemēram, ražotājs-patērētājs modeļa gadījumā.
- ArrayBlockingQueue: fiksētas ietilpības masīva realizācija ar BlockingQueue.
- LinkedBlockingQueue: saistīta saraksta realizācija ar izvēles ietilpību.
- SynchronousQueue: nulles ietilpības rinda. Katras ievietošanas operācija gaida atbilstošu izņemšanas operāciju un otrādi.
ConcurrentLinkedQueue: straumes droša saistīta saraksta realizācija ar Queue. Neatbalsta bloķējošas operācijas.

Atšķirības no sinhronizētajām kolekcijām (Collections.synchronizedList, Collections.synchronizedMap un tml.):

Sinhronizētās kolekcijas izmanto pilnu objekta līmeņa bloķēšanu, kas var samazināt veiktspēju lielas konkurences gadījumā.
Daudzstraumes kolekcijas, piemēram, ConcurrentHashMap, izmanto sīkāku bloķēšanu vai citus mehānismus labākai veiktspējai.
Sinhronizēto kolekciju iteratori var mest ConcurrentModificationException kolekciju modificējot citā straumē. Daudzstraumes kolekcijas parasti ir izturīgākas pret šādām izmaiņām.

Konkrētas daudzstraumes kolekcijas izvēle ir atkarīga no lietošanas scenārija: lasīšanas/rakstīšanas biežuma, bloķējošo operāciju nepieciešamības, veiktspējas prasībām un tml.

ConcurrentHashMap piemērs:

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); // Straumes droša operācija
    }

    public Integer getValue(String key) {
        return map.get(key); // Straumes droša operācija
    }

    public void incrementValue(String key) {
        // Atomiska operācija: ja raktelis nav, ievieto 1, citādi palielina esošo vērtību
        map.compute(key, (k, v) -> (v == null) ? 1 : v + 1);
    }
}

BlockingQueue piemērs:

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

public class ProducerConsumer {

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

    // Ražotāja straume
    public void produce(Integer item) throws InterruptedException {
        queue.put(item); // Blokējas, ja rinda ir pilna
        System.out.println("Produced: " + item);
    }

    // Patērētāja straume
    public Integer consume() throws InterruptedException {
        Integer item = queue.take(); // Blokējas, ja rinda ir tukša
        System.out.println("Consumed: " + item);
        return item;
    }
}

Ko jūs varat pastāstīt par daudzprocesu kolekcijām Java?