java设计模式之（一）- 单例模式（八种）

概述

单例模式（Singleton Pattern）是java中最常见的设计模式之一。其定义是单例对象的类只能允许创建一个实例，而可以被多次调用。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

• 特点：

1.单例类只能有一个实例。
2.单例类必须自己创建自己的唯一实例。
3.单例类必须给所有其他对象提供这一实例。
总结要点：构造方法私有，静态方法提供唯一实例。

• 应用场景:

1.需要频繁的进行创建和销毁的对象；
2.创建对象时耗时过多或耗费资源过多，但又经常用到的对象；
3.工具类对象；
4.频繁访问数据库或文件的对象。

八种写法

一、饿汉式（静态常量）-【可用】

public class Singleton {

    private static Singleton instance = new Singleton();

    private Singleton() {}

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

优点：写法简单，在类装载时完成实例化，避免了线程同步问题。
缺点：在类装载时就完成实例化，没有达到Lazy Loading的效果。如果从未使用过这个实例，则会造成内存的浪费。

注:在JDK中,java.lang.Runtime就是使用的此种方式。

二、饿汉式（静态常量）-【可用】

public class Singleton {

    private static Singleton instance;
    
    static {
        instance = new Singleton();
    }

    private Singleton() {}

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

和上面饿汉式起到同样的作用，优缺点也相同。

三、懒汉式（线程不安全）-【不可用】

public class Singleton {
    
    private static Singleton instance;

    private Singleton() {}

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

优点：起到了Lazy Loading的效果，但是只能在单线程下使用。
缺点：如果在多线程下，一个线程进入了if (instance == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这是便会长生多个实例。所以在多线程环境下不可使用这种方式。

四、懒汉式（线程安全，同步方法）-【不推荐用】

public class Singleton {
    
    private static Singleton instance;

    private Singleton() {}

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

优点：解决了线程不安全问题。
缺点：效率太低了，每个线程在执行getInstance()方法时都要进行同步。而其实只要保证第一次创建实例时同步即可。

五、懒汉式（线程安全，同步代码块）-【不可用】

public class Singleton {

    private static Singleton instance;

    private Singleton() {}

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

说明：这种方式本意是想对上一种实现方式的改进，因为前面同步方法的效率太低，改为同步产生实例化的代码块。
但是这种同步并不能起到线程安全的作用。和第一种懒汉式遇到的情形一致，假如一个线程进入了if (instance == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这是便会长生多个实例

六、双重校验锁-【可用】

public class Singleton {

    private static volatile Singleton instance;

    private Singleton() {}

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

说明：Double-Check概念是多线程开发中常使用到的，如代码所示，我们进行了两次if (instance == null)检查，这样就可以保证线程安全了。
注意：因为使用了volatile关键字，所以在JDK1.5之后，双重检查锁才能够正常达到单例的效果。

七、静态内部类-【推荐使用】

public class Singleton {

    private Singleton() {}

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

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

说明：
1.这种方式采用了类装载的机制来保证初始化实例时只有一个线程。
2.静态内部类方式在Singleton类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载SingletonInstance类，从而完成Singleton的实例化。
3.类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。
4.避免了线程不安全，利用静态内部类特点实现延迟加载，效率高。

八、枚举-【推荐使用】

public enum Singleton {
    INSTANCE;
    public void method() {
        //方法
    }
}

说明：这种方式是Effective Java作者Josh Bloch提倡的方式，借助JDK1.5中添加的枚举来实现单例模式，不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。