Are Java static initializers thread safe?

Question

I'm using a static code block to initialize some controllers in a registry I have. My question is therefore, can I guarantee that this static code block will only absolutely be called once when the class is first loaded? I understand I cannot guarantee when this code block will be called, I'm guessing its when the Classloader first loads it. I realize I could synchronize on the class in the static code block, but my guess is this is actually what happens anyway?

Simple code example would be;

class FooRegistry {

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

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

or should I do this;

class FooRegistry {

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

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

Boarer

I don't like this design, since it is untestable. Have a look at Dependency Injection. – Handpick

Answer 1

Yes, Java static initializers are thread safe (use your first option).

However, if you want to ensure that the code is executed exactly once you need to make sure that the class is only loaded by a single class-loader. Static initialization is performed once per class-loader.

Electrophilic

However, a class can be loaded by multiple class-loaders so addController may still get called more than once (regardless of whether or not you synchronize the call)... – Electrophilic

Ah hang on then, so we're saying that the static code block actually gets called for every classloader that loads the class.? Hmm... I guess this should still be ok, however, im wondering how running this sort of code in an OSGI env would work, with mulitple bundle classloaders.. – Boarer

Yes. The static code block get called for every class-loader that loads the class. – Electrophilic

@Boarer Yes, but it would operate in a different class object in each ClassLoader. Different Class objects that still have the same fully-qualified name, but represent different types that cannot be cast to one another. – Laconic

does this mean that the 'final' keyword is redundant in the instance holder in: en.wikipedia.org/wiki/Initialization-on-demand_holder_idiom ? – Homer

Answer 2

This is a trick you can use for lazy initialization

enum Singleton {
    INSTANCE;
}

or for pre Java 5.0

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

As the static block in SingletonHolder will run once in a thread safe manner you don't need any other locking. The class SingletonHolder will only get loaded when you call instance()

Tympanic

You're basing this answer on the fact that the static block will only be executed once globally--which is the very question that was asked. – Scandal

I think this too is not safe in multi-class loader environment what say.? – Maisel

@Maisel Multi-class loader environments are designed to allow each application to have it's own singletons. – Tympanic

There is no need for the nested class. This construct works the same when the INSTANCE field has been declared directly in Singleton (as is the case for the enum variant). – Bushhammer

Answer 3

In usual circumstances everything in the static initialiser happens-before everything that uses that class, so synchronisation is not usually necessary. However, the class is accessible to anything that the static intiailiser calls (including causing other static initialisers to be invoked).

A class can be loaded by a class loaded but not necessarily initialised straight away. Of course, a class can be loaded by multiples instances of class loaders and thereby become multiple classes with the same name.

Kaylee

Answer 4

Yes, sort of

A static initializer only gets called once, so by that definition it's thread safe -- you'd need two or more invocations of the static initializer to even get thread contention.

That said, static initializers are confusing in many other ways. There's really no specified order in which they're called. This gets really confusing if you have two classes whose static initializers depend on each other. And if you use a class but don't use what the static initializer will set up, you're not guaranteed the class loader will invoke the static initializer.

Finally, keep in mind the objects you're synchronizing on. I realize this isn't really what you're asking, but make sure your question isn't really asking if you need to make addController() thread-safe.

Allege

There is a very defined order in which they are called: By order in the source code. – Vd

Also, they are always called, no matter if you use their result. Unless this was changed in Java 6. – Vd

Within a class, initializers follow the code. Given two or more classes, it's not so defined as which class gets initialized first, whether one class gets initialized 100% before another starts, or how things are "interleaved". E.g. if two classes each have static initalializers referring to each other, things get ugly fast. I thought there were ways you could refer to a static final int to another class w/o invoking the initializers but I'm not going to argue the point one way or another – Allege

It does get ugly, and I'd avoid it. But there is a defined way for how cycles are resolved. Quoting "The Java Programming Language 4th Edition": Page: 75, Section: 2.5.3. Static Initialization: "If cycles happen, X's static initializers will have been executed only to the point where Y's method was invoked. When Y, in turn, invokes the X method, that method runs with the rest of the static initializers yet to be executed" – Absentee

Answer 5

Yes, Static initializers are run only once. Read this for more information.

Mantelpiece

No, they can be run more than once. – Childe

No they can be run once PER CLASSLOADER. – Severen

Basic answer: Static init only runs once. Advanced answer: Static init runs once per class loader. First comment is confusing because phrasing mixes these two answers. – Absentee

Answer 6

So basically, since you want a singleton instance, you should do it more or less the old-fashioned way and make sure your singleton object is initialised once and only once.

Severen