util.concurrent.atomic.AtomicBoolean: riferimento pratico
util.concurrent.atomic.AtomicBoolean: riferimento pratico: AtomicBoolean mantiene un boolean aggiornabile atomicamente con effetti di memoria da plain a volatile.
CKTIS / Java
Sintassi, operatori e concetti di programmazione. Trova una spiegazione, consulta un esempio e torna a imparare.
util.concurrent.atomic.AtomicBoolean: riferimento pratico: AtomicBoolean mantiene un boolean aggiornabile atomicamente con effetti di memoria da plain a volatile.
AtomicInteger offre operazioni atomiche su un singolo valore int condiviso tra thread. Scopri come leggere, scrivere, incrementare e aggiornare in modo condizionale, e quali sono i limiti dell’atomicità.
AtomicLong contiene un singolo valore long e offre aggiornamenti atomici condivisi tra thread. Il metodo incrementAndGet() aumenta il valore di uno e restituisce il risultato aggiornato.
AtomicReference<V> offre operazioni atomiche su un singolo riferimento. Scopri le differenze tra get(), la sostituzione condizionale con compareAndSet() e quella incondizionata con getAndSet(), e perché il successo di una sostituzione condizionale dipende dall’identità dell’oggetto, non dall’uguaglianza del suo contenuto.
LongAccumulator combina valori long usando una funzione fornita. Supporta aggiornamenti concorrenti, ma get() non fornisce uno snapshot atomico dello stato mentre gli aggiornamenti sono in corso.
LongAdder accumula una somma di tipo long aggiornata da più thread. È adatto alle statistiche, ma sum() non fornisce un’istantanea atomica e, per azzerarlo, occorre controllare gli aggiornamenti concorrenti.
BlockingQueue<E> consente di scambiare elementi tra thread in modo sicuro, ad esempio tra un produttore e un consumatore. Distingue le operazioni che non attendono spazio o elementi, quelle in attesa e le varianti con limite di tempo. L’esempio usa una ArrayBlockingQueue con capacità 1.
util.concurrent.Callable: riferimento pratico: Callable<V> è un’interfaccia funzionale per un compito senza argomenti che restituisce V e può generare Exception.
CompletableFuture<T> rappresenta un risultato futuro e permette di collegare fasi dipendenti senza bloccare dopo ogni passaggio. Scopri trasformazioni, composizione, combinazione dei risultati, recupero dagli errori e timeout in Java SE 21.
util.concurrent.CompletionService: riferimento pratico: CompletionService<V> separa l’invio dei compiti dal recupero dei Future in ordine di completamento.
util.concurrent.CompletionStage: riferimento pratico: CompletionStage<T> descrive una fase di calcolo che esegue un’azione o calcola un valore quando si completa un’altra fase.
ConcurrentHashMap permette a più thread di usare in sicurezza una mappa condivisa. Le operazioni atomiche su una chiave, però, non trasformano una sequenza di chiamate in una transazione.
Scopri ConcurrentLinkedQueue e i metodi add, isEmpty e poll per inserire elementi, verificare se la coda è vuota e recuperare elementi in modo sicuro.
util.concurrent.CopyOnWriteArrayList: riferimento pratico: CopyOnWriteArrayList<E> è una lista thread-safe che copia l’intero array sottostante a ogni modifica.
CountDownLatch coordina i thread: await() attende finché le chiamate a countDown() non portano il contatore a zero. Consente di attendere un gruppo di operazioni e garantisce la visibilità delle scritture precedenti.
CyclicBarrier sincronizza un numero fisso di partecipanti ai confini di fasi successive. La chiamata a await() attende gli altri; un’azione facoltativa combina i risultati prima che inizi la fase successiva.
java.util.concurrent.Executor accetta attività Runnable tramite execute. Separa l’invio delle attività dalla modalità di esecuzione; non garantisce né un thread separato né un’esecuzione asincrona.
java.util.concurrent.Executors fornisce metodi factory per gli executor di task. Executors.newFixedThreadPool limita il numero di thread di lavoro attivi, ma non la dimensione della coda. Scopri come recuperare i risultati e chiudere il pool in Java SE 21.
ExecutorService separa l’invio delle attività dalla gestione della loro esecuzione. Scopri submit, l’esecuzione in blocco con invokeAll e shutdown, e la differenza tra richiedere l’arresto e attenderne il completamento.
util.concurrent.Flow: riferimento pratico: Flow raggruppa le interfacce Publisher, Subscriber, Subscription e Processor compatibili con Reactive Streams e controllo della domanda.
Future<V> rappresenta il risultato di un’attività asincrona. Future.get recupera il risultato, attendendo se necessario, mentre Future.isDone verifica il completamento, che non implica necessariamente un esito positivo.
LinkedBlockingQueue è una coda FIFO thread-safe basata su nodi concatenati. Supporta un limite di capacità facoltativo e operazioni che attendono spazio libero o un elemento, risultando utile per la comunicazione tra produttori e consumatori.
Condition consente a un thread di attendere una modifica dello stato condiviso protetto da un Lock. Scopri await, awaitNanos, signal e signalAll e perché il controllo dello stato va eseguito in un ciclo.
L’interfaccia java.util.concurrent.locks.Lock consente di controllare esplicitamente i lock. Scopri la coppia lock()/unlock(), il modello sicuro try/finally e un esempio in cui ReentrantLock protegge un contatore condiviso.