【每日学设计模式——创建型模式】 单例模式

菜鸟教程链接：单例模式

概念

单例模式是Java中最常用，也是最简单的设计模式。通过私有化类的构造方法，禁止外部实例化该类对象，而是通过类自身创建一个唯一实例，并提供一个接口给外部使用，保证该类在项目中只有唯一的实例，既保证了类实例的唯一稳定性，也节约了内存资源。枚举是单例模式最常见的使用。
可简单将单例模式归纳与以下三点：
1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须向外提供暴露该实例的接口。

优缺点

优点：

1. 节约资源，避免重复的类对象的创建于销毁
2. 避免对资源的多重占用
3. 统一项目中该类实例的状态

缺点：

1. 没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。
2. 创建的类无法做修改，强行修改可能会导致全局。

适用场景

1. 需要全局确定的唯一标识，比如通过枚举类提供确定的标识字符。
2. 实例的创建大量消耗资源，而且大部分场景无需对类的实例有个性化的要求。

示例代码

1.懒汉式：通过私有类实例为静态成员变量，在需要第一次用到类实例时创建。效率低，但是节约内存。未加锁，所以多线程无法使用。

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

2. 饿汉式：在类加载时便创建对应的实例对象。效率高，但占用内存。线程安全。

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

3. 双检锁/双重校验锁（DCL，即 double-checked locking）：通过双锁，高性能时保持线程安全。（只有第一次加载时候会加锁）

public class Singleton {  
    private volatile static Singleton singleton;  
    private Singleton (){}  
    public static Singleton getSingleton() {  
    if (singleton == null) {  
        synchronized (Singleton.class) {  
            if (singleton == null) {  
                singleton = new Singleton();  
            }  
        }  
    }  
    return singleton;  
    }  
}

4. 登记式/静态内部类：这种方式只适用于静态域的情况，对静态域使用延迟初始化，双检锁方式可在实例域需要延迟初始化时使用。

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

5. 枚举： 最完美的单例模式，可利用于service等业务对象中，是很高级的单例模式利用。
   普通枚举

public enum Singleton {  
    INSTANCE;  
    public void whateverMethod() {  
    }  
}

通过枚举去实现一个功能接口，利用每个枚举，重写接口的功能方法来实现不同实现类一样的效果（原理和内部类一致么？），结合枚举自身提供的暴露对象接口，甚至更简洁的完成策略模式！
功能接口：

public interface EnumService {
    void process();
}

枚举：

public enum EnumServiceImpl implements EnumService{
    SERVICE_ONE("ONE"){
        @Override
        public void process() {
            System.out.println("process service one..");
        }
    },

    SERVICE_TWO("TWO"){
        @Override
        public void process() {
            System.out.println("process service two..");
        }
    };

    private String type;

    EnumServiceImpl(String type) {
        this.type = type;
    }

    public String getType() {
        return type;
    }

    public static EnumServiceImpl getInstance(String type) {
        for (EnumServiceImpl value : EnumServiceImpl.values()) {
            if (value.getType().equals(type)) {
                return value;
            }
        }
        return null;
    }
}

测试一下：

public class Test {

    public static void main(String[] args) {
        test("ONE");
        test("TWO");
    }

    private static void test(String type) {
        EnumServiceImpl.getInstance(type).process();
    }
}

输出结果：
process service one…
process service two…

是不是完美体现了单例模式和策略模式的结合呢！