Applicazioni pratiche per AtomicInteger

Question

Capisco che AtomicInteger e altre variabili atomiche consentano accessi concorrenti. In quali casi viene usata tipicamente questa classe?

Answer 1

Ci sono due usi principali di AtomicInteger:

• Come un contatore atomica (incrementAndGet(), ecc) che può essere utilizzato da molti fili contemporaneamente

• Come primitiva che supporta compare-and-swap istruzione (compareAndSet()) per implementare algoritmi non bloccanti.

  Ecco un esempio di non-blocking generatore di numeri casuali da Brian Göetz's Java Concurrency In Practice:

  public class AtomicPseudoRandom extends PseudoRandom { 
      private AtomicInteger seed; 
      AtomicPseudoRandom(int seed) { 
       this.seed = new AtomicInteger(seed); 
      } 
  
      public int nextInt(int n) { 
       while (true) { 
        int s = seed.get(); 
        int nextSeed = calculateNext(s); 
        if (seed.compareAndSet(s, nextSeed)) { 
         int remainder = s % n; 
         return remainder > 0 ? remainder : remainder + n; 
        } 
       } 
      } 
      ... 
  } 
  

  Come si può vedere, esso funziona praticamente quasi nello stesso modo come incrementAndGet(), ma esegui calcolo arbitrario (calculateNext()) invece di incremento (e elabora il risultato prima del ritorno).

Answer 2

La chiave è che consentono l'accesso e la modifica simultanei in modo sicuro. Sono comunemente usati come contatori in un ambiente con multithreading - prima della loro introduzione questo doveva essere una classe scritta dall'utente che racchiudeva i vari metodi nei blocchi sincronizzati.

Answer 3

L'esempio più semplice che posso pensare è di incrementare un'operazione atomica.

Con int standard:

private volatile int counter; 

public int getNextUniqueIndex() { 
    return counter++; // Not atomic, multiple threads could get the same result 
} 

Con AtomicInteger:

private AtomicInteger counter; 

public int getNextUniqueIndex() { 
    return counter.getAndIncrement(); 
} 

Quest'ultimo è un modo molto semplice per eseguire semplici effetti mutazioni (specialmente contando, o unico indicizzazione), senza dover ricorrere alla sincronizzazione di tutti gli accessi.

logica privo di sincronizzazione Più complesso può essere impiegato utilizzando compareAndSet() come un tipo di blocco ottimistico - ottenere il valore corrente, risultato di calcolo sulla base di questo, impostare questo risultato sse valore è ancora l'ingresso utilizzato per eseguire il calcolo , altrimenti ricominciare - ma gli esempi di conteggio sono molto utili e userò spesso AtomicIntegers per il conteggio e generatori unici a livello di VM se c'è qualche suggerimento di più thread coinvolti, perché sono così facili da lavorare con I'd quasi considerare l'ottimizzazione prematura per usare il semplice ints.

Mentre è quasi sempre possibile ottenere le stesse garanzie di sincronizzazione con ints ed appropriate synchronized dichiarazioni, la bellezza di AtomicInteger è che il filo di sicurezza è incorporato nella all'oggetto vero e proprio, piuttosto che doversi preoccupare di possibili interleavings, e monitorati, di tutti i metodi che accedono al valore int. È molto più difficile violare accidentalmente il threadsafety quando si chiama getAndIncrement() di quando si restituisce i++ e si ricorda (o meno) di acquisire in anticipo il set corretto di monitor.

Answer 4

Ad esempio, ho una libreria che genera istanze di qualche classe. Ciascuna di queste istanze deve avere un ID intero univoco, poiché queste istanze rappresentano i comandi inviati a un server e ogni comando deve avere un ID univoco.Poiché più thread sono autorizzati a inviare comandi contemporaneamente, io uso un AtomicInteger per generare quegli ID. Un approccio alternativo sarebbe utilizzare una sorta di blocco e un numero intero regolare, ma è più lento e meno elegante.

Answer 5

L'utilizzo principale di AtomicInteger è quando si è in un contesto con multithreading ed è necessario eseguire operazioni di sicurezza thread su un numero intero senza utilizzare synchronized. L'assegnazione e il recupero sul tipo primitivo int sono già atomici ma AtomicInteger viene fornito con molte operazioni che non sono atomiche su int.

I più semplici sono getAndXXX o xXXAndGet. Ad esempio, getAndIncrement() è un equivalente atomico a i++ che non è atomico perché è in realtà una scorciatoia per tre operazioni: recupero, aggiunta e assegnazione. compareAndSet è molto utile per implementare semafori, serrature, fermi, ecc.

L'utilizzo di AtomicInteger è più veloce e più leggibile rispetto all'utilizzo dello stesso tramite la sincronizzazione.

Un semplice test:

public synchronized int incrementNotAtomic() { 
    return notAtomic++; 
} 

public void performTestNotAtomic() { 
    final long start = System.currentTimeMillis(); 
    for (int i = 0 ; i < NUM ; i++) { 
     incrementNotAtomic(); 
    } 
    System.out.println("Not atomic: "+(System.currentTimeMillis() - start)); 
} 

public void performTestAtomic() { 
    final long start = System.currentTimeMillis(); 
    for (int i = 0 ; i < NUM ; i++) { 
     atomic.getAndIncrement(); 
    } 
    System.out.println("Atomic: "+(System.currentTimeMillis() - start)); 
} 

Sul mio PC con Java 1.6 viene eseguito il test atomico in 3 secondi, mentre quello sincronizzato viene eseguito in circa 5,5 secondi. Il problema qui è che l'operazione di sincronizzazione (notAtomic++) è veramente breve. Quindi il costo della sincronizzazione è molto importante rispetto all'operazione.

Beside atomicity AtomicInteger può essere utilizzato come versione mutabile di Integer per esempio in Map s come valori.

Answer 6

Se si osservano i metodi di AtomicInteger, si noterà che tendono a corrispondere alle operazioni comuni sugli interi. Per esempio:

static AtomicInteger i; 

// Later, in a thread 
int current = i.incrementAndGet(); 

è la versione thread-safe di questo:

static int i; 

// Later, in a thread 
int current = ++i; 

I metodi mappa simili:
++i è i.incrementAndGet()
i++ è i.getAndIncrement()
--i è i.decrementAndGet()
i-- è i.getAndDecrement()
i = x è i.set(x)
x = i è x = i.get()

ci sono altri metodi di convenienza pure, come compareAndSet o addAndGet

Answer 7

Come gabuzo ha detto, a volte io uso AtomicIntegers quando voglio passare un int per riferimento. È una classe built-in che ha un codice specifico per l'architettura, quindi è più facile e probabilmente più ottimizzato di qualsiasi MutableInteger che potrei rapidamente codificare. Detto questo, sembra un abuso della classe.

Answer 8

È possibile implementare blocchi non bloccanti utilizzando compareAndSwap (CAS) su numeri interi o numeri interi atomici.Il documento descrive questo "Tl2" Software Transactional Memory:

Associamo uno speciale controllo di versione write-lock con ogni transato posizione di memoria. Nella sua forma più semplice, il blocco scrittura versione è uno spinlock a parola singola che utilizza un'operazione CAS per acquisire il blocco e lo store per il rilascio. Dal momento che è sufficiente un solo bit per indicare per il blocco, usiamo il resto della parola di blocco per contenere un numero di versione .

Quello che viene descritto è la prima lettura del numero intero atomico. Dividi questo in un lock-bit ignorato e il numero di versione. Tentativo di CAS scriverlo come lock-bit cancellato con il numero di versione corrente sul set di lock-bit e sul numero di versione successivo. Fai il ciclo fino a quando non ci riesci e sei il filo che possiede il lucchetto. Sbloccare impostando il numero di versione corrente con il bit di blocco deselezionato. Il documento descrive l'uso dei numeri di versione nei blocchi per coordinare i thread che hanno un insieme coerente di letture quando scrivono.

This article descrive che i processori dispongono di supporto hardware per operazioni di confronto e scambio che rendono molto efficienti. Essa sostiene anche:

non-blocking contatori CAS-based utilizzando le variabili atomiche hanno prestazioni migliori di contatori di lock-base in basso a moderato contesa

Answer 9

io di solito uso AtomicInteger quando ho bisogno di dare Ids agli oggetti che possono essere aggiunti o creati da più thread e di solito li uso come attributo statico sulla classe a cui accedo nel costruttore degli oggetti.

Answer 10

In Java 8 classi atomiche sono state estese con due funzioni interessanti:

• int getAndUpdate (IntUnaryOperator updateFunction)
• int updateAndGet (IntUnaryOperator updateFunction)

Entrambi utilizzano l'updateFunction a eseguire l'aggiornamento del valore atomico. La differenza è che il primo restituisce il vecchio valore e il secondo restituisce il nuovo valore. La funzione update può essere implementata per eseguire operazioni di "confronto e impostazione" più complesse rispetto a quella standard. Ad esempio si può verificare che contatore atomico non va sotto zero, normalmente richiederebbe sincronizzazione, e qui il codice è-lock gratis:

public class Counter { 

     private final AtomicInteger number; 

     public Counter(int number) { 
     this.number = new AtomicInteger(number); 
     } 

     /** @return true if still can decrease */ 
     public boolean dec() { 
     // updateAndGet(fn) executed atomically: 
     return number.updateAndGet(n -> (n > 0) ? n - 1 : n) > 0; 
     } 
    } 

Il codice viene preso da Java Atomic Example.