144

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) {
        // ...
    }
}
ydaetskcoR
  • 53,225
  • 8
  • 158
  • 177
simon622
  • 3,248
  • 3
  • 19
  • 12
  • 10
    I don't like this design, since it is untestable. Have a look at Dependency Injection. – dfa May 18 '09 at 16:48

6 Answers6

209

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.

Matthew Murdoch
  • 30,874
  • 30
  • 96
  • 127
  • 2
    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)... – Matthew Murdoch May 18 '09 at 17:00
  • 4
    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.. – simon622 May 18 '09 at 17:11
  • 1
    Yes. The static code block get called for every class-loader that loads the class. – Matthew Murdoch May 20 '09 at 08:53
  • 3
    @simon622 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. – Erwin Bolwidt Jan 08 '16 at 08:51
  • 1
    does this mean that the 'final' keyword is redundant in the instance holder in: https://en.wikipedia.org/wiki/Initialization-on-demand_holder_idiom ? – spc16670 Jun 27 '16 at 07:13
13

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()

Peter Lawrey
  • 525,659
  • 79
  • 751
  • 1,130
  • 20
    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. – Michael Myers May 18 '09 at 19:15
  • 2
    I think this too is not safe in multi-class loader environment what say.? – Ahmad Sep 25 '12 at 15:58
  • 2
    @Ahmad Multi-class loader environments are designed to allow each application to have it's own singletons. – Peter Lawrey Apr 18 '13 at 11:11
  • 1
    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). – Holger Oct 22 '20 at 07:21
4

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.

Tom Hawtin - tackline
  • 145,806
  • 30
  • 211
  • 305
3

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.

Sai Kishore
  • 326
  • 1
  • 7
  • 16
Matt
  • 2,001
  • 2
  • 17
  • 15
  • 5
    There is a very defined order in which they are called: By order in the source code. – mafu May 20 '09 at 09:09
  • Also, they are always called, no matter if you use their result. Unless this was changed in Java 6. – mafu May 20 '09 at 09:11
  • 9
    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 – Matt May 23 '09 at 02:19
  • 1
    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" – KANJICODER Jul 10 '18 at 20:21
0

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

Mike Pone
  • 18,705
  • 13
  • 53
  • 68
-4

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.

ruurd
  • 131
  • 1
  • 4