Java Design Pattern 2

Single Design pattern

对于单例模式的理解，我将之描述为：单例模式只拥有一个实例，它的实例由自己构建，并将之提供给其它对象。
＃
单例模式用于解决一个类对象频繁实例化和销毁等问题
存在的缺点是：没有接口，不能继承。同时，类的设计也违背了职责单一的原则，类应该只关心类的内部逻辑，不应该关心外部是如何实例化它的。

应用场景

• 用于生产唯一的序列码
• web项目中的计数器，不需要每次都更新到数据库，可以用单例缓存
• 创建和销毁对象会消耗过多资源的地方，例如io和数据库的连接

---

简单实现－饿汉式

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

    public Singleton getInstance(){
        return instance;
    }

    private Singleton(){
    }

    public void sayHello(){
        sout("hello world!");
    }
}

懒汉式－线程不安全

public class Singleton {  
    private static Singleton instance;  
    private Singleton (){}  

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

懒汉式－线程安全

public class Singleton {  
    private static Singleton instance;  
    private Singleton (){}  

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

DCL(double-checked locking)双重锁校验模式

public class Singleton{
    private static volatile Singleton instance;

    private Singleton(){}

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

登记式／静态内部类方式

能达到和dcl相同的效果，但是实现更为简单的方式。静态内部类的意义在于singleton类加载的时候，实例不会被加载，只有当SingletonHolder被加载的时候才会加载实例，这样就达到了lazy loading。这也是和dcl方式的区别

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

    private Singleton(){}

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

枚举方式

public enum Singleton{
    INSTANCE;
    public void sayHello(){
        sout("hello world!");
    }
}

枚举，绝对的保证实例的唯一，序列的唯一以及多线程下的安全性。

通常情况下，不建议使用懒汉式的两种方式。而是使用饿汉式，而如果场景明确需要用lazy loading的方式，那么久使用登记式（静态内部类）的方式。如果涉及到反序列化的问题，则可以考虑枚举方式。如果有其它的要求，才考虑dcl的方式。