单例模式

创立型模式

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

留神：

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;    }}

长处:

这种形式能达到双检锁形式一样的效用，但实现更简略。
这种形式采纳了类装载的机制来保障初始化实例时只有一个线程。
动态外部类的形式在Singleton类被装载的时候并不会立刻初始化 , 而是在须要实例化时，调用getInstance办法才会装载SingletonInstance类，从而实现Singleton的实例化。
类的动态属性只会在第一次加载类的时候进行初始化，所以这里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 提倡的形式，它不仅能防止多线程同步问题，而且还主动反对序列化机制，避免反序列化从新创立新的对象，相对避免屡次实例化。

总结:

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