Sincronizzazione thread su variabile istanza Integer

Question

public class Main{ 
    public static void main(String[] args) throws Exception { 
     // Creating objects for class Check(2 different objects) 
     Check c = new Check("s1"); 
     Check c1 = new Check("s2"); 
     c.start();c1.start(); 
    } 
} 
class Check extends Thread{ 
    Check(String name){super(name);} 
    private Integer ab = 2; 
    public void run(){ 
     synchronized (ab) { 
      System.out.println(Thread.currentThread().getName()); 
      for(int i=0;i<10;i++)System.out.print(i+" "); 
     } 
    } 
} 

Qui ho sincronizzato sulla variabile ab. E ho anche creato due diverse istanze di controllo di classe, ma ottengo sempre output per s1 seguito da s2 o viceversa, ma non misto, perché è così? quando ho già creato due oggetti separati (in main), quindi due thread differenti, due diverse variabili ab, quindi come diventa una risorsa condivisa per i due diversi oggetti?

Answer 1

TL; DR - è a causa di Integer pooling. Effettuare un Object (ad esempio Object ab = new Object()) per garantire che ogni istanza del blocco di Check non interferisca con gli altri.

---

Inizialmente ero perplesso. È interessante notare che, se si cambia

private Integer ab = 2; 

a

private Object ab = new Object(); 

la sincronizzazione va via (si ottiene diverse uscite su ogni corsa). Indietro con ab come Integer, ho eseguito il codice in modalità di debug (con un punto di interruzione sulla riga del nome del thread di stampa) e ho trovato quanto segue. Ecco il primo thread:

Ed ecco il secondo thread.

Si noti che in realtà è lo stesso oggetto, Integer@443. Anche se hai pensato di ottenere due oggetti diversi, entrambi i campi ab nelle due istanze di Verifica si riferiscono allo stesso oggetto in memoria! Quindi sì, c'è la sincronizzazione corretta. La domanda, quindi, è come dicendo che lo Integer ab = 2 riceve due volte lo stesso oggetto Integer in memoria.

---

Dicendo Integer ab = 2, si utilizza autoboxing, con cui un valore di base (di tipo int) viene convertito automaticamente nel corrispondente oggetto Integer. Ciò equivale a chiamare il metodo autoboxing chiamata:

private Integer ab = Integer.valueOf(2); 

Se guardiamo in Integer.valueOf, notiamo che ha una piscina per i valori in un determinato intervallo:

public static Integer valueOf(int i) { 
    if (i >= IntegerCache.low && i <= IntegerCache.high) 
     return IntegerCache.cache[i + (-IntegerCache.low)]; 
    return new Integer(i); 
} 

Per la maggior parte delle impostazioni convenzionali, questo includerà il valore 2. Quindi stai ricevendo lo stesso valore Integer quando chiami questo metodo.

Answer 2

Se si dà un'occhiata a bytecode si sarebbe probabilmente vedere questo codice:

LINENUMBER 15 L1 
ALOAD 0 
ICONST_2 
INVOKESTATIC java/lang/Integer.valueOf (I)Ljava/lang/Integer; 
PUTFIELD com/example/Check.ab : Ljava/lang/Integer; 

Java cerca di box il valore di base 2 di opporsi chiamando #valueOf di Integer di classe. E come sappiamo, lo valueOf degli Integer implementa il modello Flyweight. Pertanto, lo stesso oggetto è condiviso tra le istanze.

Answer 3

Questo sta accadendo a causa del concetto Ingeter Pool in Java.

I numeri interi compresi tra -128 e 127 (inclusi) vengono utilizzati allo stesso modo del pool di stringhe.

Pertanto, quando si utilizza private Integer ab = 2;, ab viene condiviso per entrambi gli oggetti di Check.

È possibile utilizzare il valore> 128 o qualsiasi altro tipo di oggetto in modo che il codice non venga sincronizzato.

È possibile visualizzare le risposte qui: Why does the behavior of the Integer constant pool change at 127? per comprendere il concetto di pool intero.