When should I use lazy Singletons over normal Singletons?

Question

So far I have seen two examples of Singletons.

Normal Singletons,

public class Singleton {
  private static Singleton instance;

  static {
    instance = new Singleton();
  }

  private Singleton() { 
    // hidden constructor
  }    

  public static Singleton getInstance() {
    return instance;
  }
}

and Lazy Singletons,

public class Singleton {

  private Singleton() { 
    // hidden constructor
  }

  private static class Holder {
    static final Singleton INSTANCE = new Singleton();
  }

  public static Singleton getInstance() {
    return Holder.INSTANCE;
  }
}

Coding is from this thread and this user. I have just recently gotten into trying to learn Singletons as my previous methods have been

1.) Using static in order to create something like ...

static MyClass instance;

2.) I would attempt to pass an instance in a seemingly odd way,

MyClass instance;

@Override
public void onEnable() { instance = this; }

// Transition to different class - - -

public OtherClass(MyClass myClass) {
    this.instance = myClass;
}

Lastly, what is my end goal? I am mainly using it in order to pass variables from my main class to other classes. I'm currently attempting to learn how to properly use Files and FileConfiguration, so I want to easily share them throughout my classes.

If I seem like a beginner, instead of going out of your way to tell me to learn Java, please provide a resource to help me with my problem first and foremost.

Dude, I think you should try to rephrase your question, it's not clear. *what is my end goal?* - you should **tell** us what's your goal and then we can try to help.. — SHG, Jan 27 '18 at 00:10
The [wikipedia article on Singletons](https://en.wikipedia.org/wiki/Singleton_pattern#Implementation) covers your question really well, actually. — Mick Mnemonic, Jan 27 '18 at 00:15
And note that technically, you need to have a `final class` to prevent sublasses from creating additional instances. — Mick Mnemonic, Jan 27 '18 at 00:17
Singletons and static variables are usual anti patterns that beginners fall for because they provide quick and easy solution but fail when codebase gets bigger and starts using TDD. In your case you better off passing those objects via constructors or setters as described by Dependency Injection practice. — tsolakp, Jan 27 '18 at 00:54
@SHG using _what is my end goal?_ was based off of normal FaQ behavior and not something meant to be answered, as it already is. — VeeAyeInIn, Jan 27 '18 at 15:51

score 7 · Answer 1 · answered Jan 27 '18 at 05:33

As to when, rather than how: I would use lazy instantiation of a singleton or of any other object when there is a fair chance of the object not being needed, and immediate instantiation when the likelihood of it being needed is high. In general, if instantiation were to fail, and the object is needed, it is better that it fail as early as possible.

Jacob G. · Answer 2 · 2018-01-27T00:20:07.333

This link explains it fairly well and even uses a similar example.

In software engineering, the initialization-on-demand holder (design pattern) idiom is a lazy-loaded singleton. In all versions of Java, the idiom enables a safe, highly concurrent lazy initialization with good performance.

Regarding why you should use this: if the creation of this instance is expensive, then this design pattern essentially delegates the expensive computation for when it is needed, rather than when the outer class, Singleton in your case, is first accessed.

Another reason is given by this other link. It states:

A singleton implementation may use lazy initialization, where the instance is created when the static method is first invoked. If the static method might be called from multiple threads simultaneously, measures may need to be taken to prevent race conditions that could result in the creation of multiple instances of the class.

When should I use lazy Singletons over normal Singletons?

2 Answers2