Come viene acquisito il blocco del livello di classe

Question

public synchronized int getCountOne() { 
     return count++; 
} 

Come nel codice sopra la sincronizzazione del metodo è funzionalmente equivalente ad avere un valore synchronized (this) block attorno al corpo del metodo. L'oggetto "questo" non diventa bloccato, piuttosto l'oggetto "questo" viene utilizzato come mutex e il corpo viene impedito di essere eseguito contemporaneamente ad altre sezioni di codice sincronizzate anche su "questo".

Per motivi analoghi quello che viene utilizzato come mutex quando si acquisisce un livello di classe lock.As a se abbiamo una funzione

public static synchronized int getCountTwo() { 
     return count++; 
} 

ovviamente due fili possono ottenere contemporaneamente blocchi su getCountOne (serratura livello oggetto) e getCountTwo (blocco livello di classe). Quindi getCountOne è analogo a

public int getCountOne() { 
    synchronized(this) { 
      return count++; 
    } 
} 

c'è un equivalente di getCountTwo? Se no, quali criteri vengono utilizzati per ottenere un blocco a livello di classe?

Answer 1

Per motivi analoghi quello che viene utilizzato come mutex quando si acquisisce una serratura livello di classe

L'oggetto classe stessa verrà usata come mutex. Il blocco sincronizzato equivalente per il metodo static synchronized sarà simile:

public static int getCountTwo() { 
    synchronized(ClassName.class) { 
      return count++; 
    } 
} 

ClassName è il nome della classe che contiene quel metodo.

Vedi JLS Section §8.4.3.6:

Procedimento sincronizzato acquisisce un monitor (§17.1) prima di eseguire.

Per un metodo di classe (statico), viene utilizzato il monitor associato all'oggetto Classe per la classe del metodo.

Per un metodo di istanza, viene utilizzato il monitor associato a questo oggetto (l'oggetto per il quale è stato richiamato il metodo).

Enfasi mia.

Answer 2

blocco a livello Oggetto:

oggetto blocco livello è meccanismo quando si desidera sincronizzare un metodo non statico o non-statico blocco di codice in modo che solo un thread sarà in grado di eseguire il blocco di codice su proposta istanza della classe. Questo dovrebbe sempre essere fatto per rendere sicuro il thread dei dati a livello di istanza. Questo può essere fatto come segue:

public class DemoClass 
{ 
    public synchronized void demoMethod(){} 
} 

or 

public class DemoClass 
{ 
    public void demoMethod(){ 
    synchronized (this) 
    { 
    //other thread safe code 
    } 
} 
} 

or 

public class DemoClass 
{ 
    private final Object lock = new Object(); 
    public void demoMethod(){ 
    synchronized (lock) 
{ 
    //other thread safe code 
} 
} 

Classe blocco a livello:

blocco a livello di Classe impedisce più thread di entrare nel blocco sincronizzato in qualsiasi di tutti i casi disponibili su runtime. Ciò significa che se in runtime ci sono 100 istanze di DemoClass, solo un thread sarà in grado di eseguire demoMethod() in una qualsiasi istanza alla volta e tutte le altre istanze saranno bloccate per altri thread.Questo dovrebbe sempre essere fatto per rendere sicuro il thread di dati statici.

public class DemoClass 
{ 
    public synchronized static void demoMethod(){} 
} 

or 

public class DemoClass 
{ 
    public void demoMethod(){ 
    synchronized (DemoClass.class) 
    { 
    //other thread safe code 
    } 
} 
} 

or 

public class DemoClass 
{ 
private final static Object lock = new Object(); 
public void demoMethod(){ 
synchronized (lock) 
    { 
    //other thread safe code 
    } 
} 
}