饿汉式

    1. /*静态常量饿汉式*/
    2. public class HungryStaticCode {
    4.     private final static HungryStaticCode hungryStaticCode = new HungryStaticCode();
    5.     private HungryStaticCode() {}
    7.     public static HungryStaticCode getInstance() {
    8.         return hungryStaticCode;
    9.     }
    10. }
    11. /*静态块饿汉式*/
    12. public class SingletonBlock {
    14.     private static SingletonBlock singletonBlock;
    15.     static {
    16.         singletonBlock = new SingletonBlock();
    17.     }
    19.     public static SingletonBlock getInstance() {
    20.         return singletonBlock;
    21.     }
    22. }
    23. //类装载时就完成了实例化，可能会造成内存浪费

    懒汉式

    1. /*线程不安全懒汉式*/
    2. public class LazyNoSafe {
    4.     private static LazyNoSafe lazyNoSafe;
    5.     private LazyNoSafe() {}
    7.     public static LazyNoSafe getInstance() {
    8.         if (lazyNoSafe == null) {
    9.             lazyNoSafe = new LazyNoSafe();
    10.         }
    11.         return lazyNoSafe;
    12.     }
    13. }
    14. /*线程安全懒汉式*/
    15. public class LazySafe {
    17.     private static LazySafe lazyNoSafe;
    18.     private LazySafe() {}
    20.     public static synchronized LazySafe getInstance() {
    21.         if (lazyNoSafe == null) {
    22.             lazyNoSafe = new LazySafe();
    23.         }
    24.         return lazyNoSafe;
    25.     }
    26. }
    27. /*同步代码块懒汉式-----不可使用*/
    28. public class LazyBlock {
    30.     private static LazyBlock lazyBlock;
    31.     private LazyBlock() {}
    33.     public static LazyBlock getInstance() {
    34.         if (lazyBlock == null) {
    35.             synchronized (LazyBlock.class) {
    36.                 lazyBlock = new LazyBlock();
    37.             }
    38.         }
    39.         return lazyBlock;
    40.     }
    41. }

    双重检测模式

    1. public class DoubleSafe {
    3.     private static DoubleSafe doubleSafe;
    4.     private DoubleSafe () {}
    6.     public static DoubleSafe getInstance() {
    7.         if (doubleSafe == null) {
    8.             synchronized (DoubleSafe.class) {
    9.                 if (doubleSafe == null) {
    10.                     doubleSafe = new DoubleSafe();
    11.                 }
    12.             }
    13.         }
    14.         return doubleSafe;
    15.     }
    16. }

    静态内部类延迟加载（推荐使用）
    懒加载+类第一次加载才会初始化，在初始化的时候别的线程无法进入，保证了线程安全

    1. public class StaticInside {
    2.     private static volatile StaticInside staticInside;
    3.     private StaticInside() {}
    4.     private static class StaticInsideInstance {
    5.         private static final StaticInside STATIC = new StaticInside();
    6.     }
    7.     public static synchronized StaticInside getInstance() {
    8.         return StaticInsideInstance.STATIC;
    9.     }
    10. }