• private constructors to prohibit external instantation of the class
• private static instance variable
• public static accessor method to obtain instance

public class Configuration {
  // the singleton instance, initialized immediately
  private static Configuration instance = new Configuration();

  // private constructor prohibits external instantiation
  private Configuration() {
    // initialization code
  }

  // public accessor method returns the instance
  public static Configuration getInstance() {
    return instance;
  }
}

Eager

Initialized when program loads

Easy implementation
Instance created even if unused
Increased application load time

public class Singleton {
  private static final Singleton instance = new Singleton();
  private Singleton() {}
  public static Singleton getInstance() {
    return instance;
  }
}

Lazy

Initialized on first access

Avoids unnecessary instantiation
Careful in multi-threaded apps
Increased operation wait time
May result in delayed failures

public class Singleton {
  private static Singleton instance;
  private Singleton() {}
  public static Singleton getInstance() {
    if (instance == null) instance = new Singleton();
    return instance;
  }
}

• static variables are class variables, access ClassName.variableName
• static methods
  • class methods
  • can only access static variables and other static methods
• static blocks
  • executed when class is loaded
  • create static resources
  • can only access static variables
• static inner class

public class Demo {
  // static variable
  public static int count;

  // static method
  public static int getCount() { 
    return count;
  }

  // static initializer block
  static {
    count = 4;
  }

  // static inner class
  static class Inner {}
}

public class Singleton {
  private static final Singleton instance = new Singleton();
}

• What if loading the singleton may raise an exception?

Solution

public class Singleton {
  private static Singleton instance;
  
  static {
    try {
      instance = new Singleton();
    } catch (Throwable e) {
      // try something else
    }
  }
  
  private Singleton() {}
}

• Thread-safe implementation of singleton without explicit synchronization
• Specific to the Java memory model and class initialization
• "Initialization-on-demand holder"
• Exploits that, in Java, static inner classes are only loaded when accessed

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

public class BankAccountGenerator {
  private static class SingletonHolder {
    static final BankAccountGenerator instance = new BankAccountGenerator();
  }
  public static BankAccountGenerator getInstance() {
    return SingletonHolder.instance;
  }

  private long nextId = 1L;
  private BankAccountGenerator() {}
  public BankAccount createAccount() {
    // create and return a new account (not thread-safe!)
    return new Account(nextId++);
  }
}

public class Demo {
  public static void main(String[] args) {
    BankAccountGenerator g = BankAccountGenerator.getInstance();
    BankAccountGenerator h = BankAccountGenerator.getInstance();
    assert g==h;
    Account a = g.createAccount();
    Account b = g.createAccount();
  }
}