I thread degli inizializzatori statici Java sono sicuri?

Sto usando un blocco di codice statico per inizializzare alcuni controller in un registro che ho. La mia domanda è quindi: posso garantire che questo blocco di codice statico venga chiamato una volta sola quando la classe viene caricata per la prima volta? Capisco che non posso garantire quando verrà chiamato questo blocco di codice, immagino che sia quando Classloader lo carica per la prima volta. Mi rendo conto che potrei sincronizzarmi sulla classe nel blocco di codice statico, ma la mia ipotesi è che in realtà è quello che succede comunque?

Sarebbe un semplice esempio di codice;

class FooRegistry {

    static {
        //this code must only ever be called once 
        addController(new FooControllerImpl());
    }

    private static void addController(IFooController controller) { 
        // ...
    }
}

o dovrei farlo;

class FooRegistry {

    static {
        synchronized(FooRegistry.class) {
            addController(new FooControllerImpl());
        }
    }

    private static void addController(IFooController controller) {
        // ...
    }
}

Sì, gli inizializzatori statici Java sono thread-safe (usa la tua prima opzione).

Tuttavia, se si desidera assicurarsi che il codice venga eseguito esattamente una volta, è necessario assicurarsi che la classe sia caricata solo da un singolo caricatore di classi. L'inizializzazione statica viene eseguita una volta per caricatore di classi.

Questo è un trucco che puoi usare per l'inizializzazione lenta

enum Singleton {
    INSTANCE;
}

o per pre Java 5.0

class Singleton {
   static class SingletonHolder {
      static final Singleton INSTANCE = new Singleton();
   }
   public static Singleton instance() {
      return SingletonHolder.INSTANCE;
   }
}

Poiché il blocco statico in SingletonHolder verrà eseguito una volta in maniera thread-safe, non è necessario alcun altro blocco. La classe SingletonHolder verrà caricata solo quando chiami istanza ()

In circostanze normali accade tutto nell'inizializzatore statico, prima di tutto ciò che usa quella classe, quindi la sincronizzazione non è di solito necessaria. Tuttavia, la classe è accessibile a tutto ciò che chiama l'intiailizzatore statico (incluso il fatto di invocare altri inizializzatori statici).

Una classe può essere caricata da una classe caricata ma non necessariamente inizializzata immediatamente. Naturalmente, una classe può essere caricata da istanze multiple di caricatori di classi e quindi diventare più classi con lo stesso nome.

Sì, una specie di

Un staticinizializzatore viene chiamato solo una volta, quindi in base a tale definizione è thread-safe: staticper ottenere la contesa del thread sono necessarie due o più chiamate dell'inizializzatore.

Detto questo, gli staticinizializzatori creano confusione in molti altri modi. Non c'è davvero nessun ordine specificato in cui vengono chiamati. Questo diventa davvero confuso se hai due classi i cui staticinizializzatori dipendono l'uno dall'altro. E se usi una classe ma non usi ciò che l' staticinizializzatore imposterà, non sei sicuro che il caricatore di classi invocherà l'inizializzatore statico.

Infine, tieni a mente gli oggetti su cui stai sincronizzando. Mi rendo conto che non è proprio quello che stai chiedendo, ma assicurati che la tua domanda non stia davvero chiedendo se devi rendere addController()sicuro il thread.

Sì, gli inizializzatori statici vengono eseguiti una sola volta. Leggi questo per maggiori informazioni .

Quindi, fondamentalmente, poiché desideri un'istanza singleton, dovresti farlo più o meno alla vecchia maniera e assicurarti che l'oggetto singleton sia inizializzato una volta e una sola volta.