I tipi di dati primitivi thread-safe in Java

Question

I tipi di dati primitivi come int & short thread-safe in Java? Ho eseguito il codice seguente e non sono riuscito a visualizzare il risultato previsto 500 alcune volte.

public class SampleThree extends Thread 
{ 
    static long wakeUpTime = System.currentTimeMillis() + (1000*20); 
    static int inT; 
    public static void main(String args[]) 
    { 
     System.out.println("initial:" + inT); 
     for(int i=0; i<500; i++) 
      new SampleThree().start(); 
     try { 
      Thread.sleep(wakeUpTime - System.currentTimeMillis() + (1000*30)); 
      System.out.println("o/p:" + inT); 
     } 
     catch(Exception e){ 
      e.printStackTrace(); 
     } 
    } 

    public void run() 
    { 
     try { 
      long s = wakeUpTime - System.currentTimeMillis(); 
      System.out.println("will sleep ms: " + s); 
      Thread.sleep(s); 
      inT++; // System.out.println(inT); 
     } 
     catch(Exception e) { 
      e.printStackTrace(); 
     } 
    } 
} 

Qui concomitanza 500 filetti aggiornerà la variabile int inT. Thread principale dopo aver atteso che l'aggiornamento simultaneo sia completato, stampa il valore inT.

Trova esempio simile here

Answer 1

Ci sono tre modi in cui non sono sicura:

• long e double non sono nemmeno garantiti da aggiornare atomico (si poteva vedere la metà di una scrittura da una filettatura diversa)
• Il modello di memoria non garantisce che vedrete gli ultimi aggiornamenti da un thread in un altro thread, senza alcuna barriera di memoria aggiuntiva di alcun tipo
• L'atto di incrementare una variabile non è atomico in ogni caso

Utilizzare AtomicInteger per operazioni thread-safe.

Answer 2

Suggerirei di utilizzare le classi in java.util.concurrent.atomic. Sono progettati per la sicurezza del thread e in alcuni casi la JVM può sfruttare le funzionalità hardware per ottimizzare.

Answer 3

I tipi primitivi non sono thread-safe. Verifica il tutorial this.