单例模式

创立型模式

这种模式波及到一个繁多的类，该类负责创立本人的对象，同时确保只有单个对象被创立。这个类提供了一种拜访其惟一的对象的形式，能够间接拜访，不须要实例化该类的对象。

留神：

• 1、单例类只能有一个实例。
• 2、单例类必须本人创立本人的惟一实例。
• 3、单例类必须给所有其余对象提供这一实例。

介绍

用意： 保障一个类仅有一个实例，并提供一个拜访它的全局拜访点。

次要解决： 一个全局应用的类频繁地创立与销毁。

何时应用： 当您想管制实例数目，节俭系统资源的时候。

如何解决： 判断零碎是否曾经有这个单例，如果有则返回，如果没有则创立。

要害代码： 构造函数是公有的。

具体实现

1. 饿汉式(动态变量)

public class SingletonTest01 {public static void main(String[] args) {Singleton singleton01 = Singleton.getInstance();
        Singleton singleton02 = Singleton.getInstance();
        System.out.println(singleton01 == singleton02); //true
        System.out.println("singleton01.hashCode =" + singleton01.hashCode()); //1625635731
        System.out.println("singleton01.hashCode =" + singleton01.hashCode()); //1625635731
    }

}

/**
 * 饿汉式(动态变量)
 */
class Singleton {
    //1. 结构器私有化，内部不能 new
    private Singleton() {}

    //2. 创立实例
    private final static Singleton instance = new Singleton();

    //3. 提供一个私有的静态方法，返回实例对象
    public static Singleton getInstance() {return instance;}

}

长处:

这种写法比较简单，就是在类装载的时候就实现了实例化。防止了线程同步问题。

毛病:

在类装载的时候就实现了实例化，没有达到 Lazy Loading 的成果。如果从始至终都没有应用过这个实例 , 则会造成内存的节约。

总结:

这种单例模式能够应用，可能 会造成内存节约。

2. 饿汉式(动态代码块)

public class SingletonTest02 {public static void main(String[] args) {Singleton singleton01 = Singleton.getInstance();
        Singleton singleton02 = Singleton.getInstance();
        System.out.println(singleton01 == singleton02); //true
        System.out.println("singleton01.hashCode =" + singleton01.hashCode()); //1625635731
        System.out.println("singleton01.hashCode =" + singleton01.hashCode()); //1625635731
    }

}

/**
 * 饿汉式(动态代码块)
 */
class Singleton {
    //1. 结构器私有化，内部不能 new
    private Singleton() {}

    //2. 申明实例
    private final static Singleton instance;

    //3. 创立实例
    static {instance = new Singleton();
    }

    //4. 提供一个私有的静态方法，返回实例对象
    public static Singleton getInstance() {return instance;}

}

总结:

这种形式的优缺点和第一种相似，只不过将类的实例化过程放在了动态代码块中，仍然可能造成内存节约。

3. 懒汉式(线程不平安)

public class SingletonTest03 {public static void main(String[] args) {Singleton singleton01 = Singleton.getInstance();
        Singleton singleton02 = Singleton.getInstance();
        System.out.println(singleton01 == singleton02); //true  (有可能为 false)
        System.out.println("singleton01.hashCode =" + singleton01.hashCode()); //1625635731
        System.out.println("singleton01.hashCode =" + singleton01.hashCode()); //1625635731
    }

}

/**
 * 懒汉式(线程不平安)
 */
class Singleton {private Singleton() { }

    public static Singleton instance;

    // 提供一个动态的私有办法，当应用到该办法时，才会创立 instance
    public static Singleton getInstance() {if (instance == null) {instance = new Singleton();
        }
        return instance;
    }
}

长处:

起到了 Lozy Loading 的成果，然而只能在 单线程 的环境下应用。

毛病:

如果在多线程环境下，大概率会产生多个实例。所以在多线程环境下不要应用这种形式。

总结:

理论开发中 不要应用这种形式。

4. 懒汉式(线程平安)

public class SingletonTest04 {public static void main(String[] args) {Singleton singleton01 = Singleton.getInstance();
        Singleton singleton02 = Singleton.getInstance();
        System.out.println(singleton01 == singleton02); //true
        System.out.println("singleton01.hashCode =" + singleton01.hashCode()); //1625635731
        System.out.println("singleton01.hashCode =" + singleton01.hashCode()); //1625635731
    }
}

/**
 * 懒汉式(线程平安)
 */
class Singleton {private Singleton() { }

    public static Singleton instance;

    // 提供一个动态的私有办法，当应用到该办法时，才会创立 instance。public static synchronized Singleton getInstance() {if (instance == null) {instance = new Singleton();
        }
        return instance;
    }
}

长处:

解决了线程不平安的问题。

毛病:

效率太低，因为是对整个办法加上了线程同步，其实只有在 new 的时候思考线程同步就行了，这种办法不举荐应用。

总结:

在理论开发中，不举荐应用这种形式。

5. 懒汉式(双重查看锁)

public class SingletonTest05 {public static void main(String[] args) {Singleton singleton01 = Singleton.getInstance();
        Singleton singleton02 = Singleton.getInstance();
        System.out.println(singleton01 == singleton02); //true
        System.out.println("singleton01.hashCode =" + singleton01.hashCode()); //1625635731
        System.out.println("singleton01.hashCode =" + singleton01.hashCode()); //1625635731
    }

}

/**
 * 懒汉式(线程平安, 双重查看锁)
 */
class Singleton {private Singleton() { }

    public static volatile Singleton instance;

    // 提供一个动态的私有办法，退出双重查看代码，解决线程平安问题，同时解决懒加载问题
    public static Singleton getInstance() {if (instance == null) {synchronized (Singleton.class) {if (instance == null) {instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

长处:

这种形式采纳双锁机制，平安且在多线程状况下能放弃高性能。

总结:

在理论开发中, 举荐应用这种单例设计模式。

6. 动态外部类

public class SingletonTest06 {public static void main(String[] args) {Singleton singleton01 = Singleton.getInstance();
        Singleton singleton02 = Singleton.getInstance();
        System.out.println(singleton01 == singleton02); //true
        System.out.println("singleton01.hashCode =" + singleton01.hashCode()); //1625635731
        System.out.println("singleton01.hashCode =" + singleton01.hashCode()); //1625635731
    }

}

/**
 * 动态外部类
 */
class Singleton {private Singleton() { }

    // 动态外部类中蕴含一个动态属性 Singleton
    private static class SingletonInstance {private static final Singleton INSTANCE = new Singleton();
    }

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

}

长处:

1. 这种形式能达到双检锁形式一样的效用，但实现更简略。
2. 这种形式采纳了类装载的机制来保障初始化实例时只有一个线程。
3. 动态外部类的形式在 Singleton 类被装载的时候并不会立刻初始化 , 而是在须要实例化时，调用 getInstance 办法才会装载 SingletonInstance 类，从而实现 Singleton 的实例化。
4. 类的动态属性只会在第一次加载类的时候进行初始化，所以这里 JVM 保障了线程安全性，在类进行初始化的时候 , 别的线程是无奈进入的。

总结:

防止了线程不平安，利用动态外部类的特点实现了提早加载，效率高，举荐应用。

7. 枚举

public class SingletonTest07 {public static void main(String[] args) {
        Singleton instance1 = Singleton.INSTANCE;
        Singleton instance2 = Singleton.INSTANCE;
        System.out.println(instance1 == instance2);
    }

}

/**
 * 枚举
 */
enum Singleton {INSTANCE;}

长处:

这种实现形式还没有被宽泛采纳，但这是实现单例模式的最佳办法。它更简洁，主动反对序列化机制，相对避免屡次实例化。
这种形式是《Effective Java》作者 Josh Bloch 提倡的形式，它不仅能防止多线程同步问题，而且还主动反对序列化机制，避免反序列化从新创立新的对象，相对避免屡次实例化。

总结:

如果波及到反序列化对象的时候能够采纳采纳这种形式，平时应用能够采纳第五种。