Java 23种设计模式之单例模式

Java 23种设计模式之单例模式

设计模式：是一套被反复使用，多数人知晓的，经过分类编目的，代码设计经验的总结。
一：设计模式的分类
创建型模式，共五种：工厂方法模式,抽象工厂模式,单例模式,建造者模式,原型模式
结构型模式，共七种：适配器模式，装饰器模式，代理模式，外观模式，桥接模式，组合模式，享元模式
行为型模式，共十一种：策略模式，模板方法模式，观察者模式，迭代子模式，责任链模式，命令模式，备忘录模式，状态模式，访问者模式，中介者模式，解释器模式
其他：并发型模式和线程池模式
二：设计模式的六大原则
1、开闭原则（Open Close Principle）
开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。
2、里氏代换原则（Liskov Substitution Principle）
里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。 LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。
3、依赖倒转原则（Dependence Inversion Principle）
这个是开闭原则的基础，具体内容：真对接口编程，依赖于抽象而不依赖于具体。
4、接口隔离原则（Interface Segregation Principle）
这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。还是一个降低类之间的耦合度的意思，从这儿我们看出，其实设计模式就是一个软件的设计思想，从大型软件架构出发，为了升级和维护方便。所以上文中多次出现：降低依赖，降低耦合。
5、迪米特法则（最少知道原则）（Demeter Principle）
为什么叫最少知道原则，就是说：一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。
6、合成复用原则（Composite Reuse Principle）
原则是尽量使用合成/聚合的方式，而不是使用继承。
三：单例模式
1.懒汉式（线程不安全）
懒汉式是用时间换空间，不加同步是线程不安全

public class Singleton {
    //2.本类内部创建对象实例
 private static Singleton instance=null;
 /*
 * 1.构造方法私有化，外部不能new*/
 private Singleton(){
        
    }
    //3.提供一个公有的静态方法，返回实例对象
 public static Singleton getInstance(){
        if (instance==null){
            instance=new Singleton();
 }
        return instance;
 }
    
}

2.懒汉式（线程安全）
添加一个synchronized同步关键字

public class Singleton {
    //2.本类内部创建对象实例
 private static Singleton instance=null;
 /*
 * 1.构造方法私有化，外部不能new*/
 private Singleton(){
    }
    //3.提供一个公有的静态方法，返回实例对象
 public static synchronized Singleton getInstance(){
        if (instance==null){
            instance=new Singleton();
 }
        return instance;
 }
}

3.懒汉式（双重检查加锁，线程安全）
对象实例上添加一个volatile字段

public class Singleton {
    //2.本类内部创建对象实例
 private volatile static Singleton instance=null;
 /*
 * 1.构造方法私有化，外部不能new*/
 private Singleton(){
    }
    //3.提供一个公有的静态方法，返回实例对象
 public static Singleton getInstance(){
        if (instance==null){
            synchronized (Singleton.class){
                if (instance==null){
                    instance=new Singleton();
 }
            }
            
        }
        return instance;
 }
}

4.饿汉式
这种方式基于classloder机制避免了多线程的同步问题，不过，instance在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用getInstance方法， 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance显然没有达到lazy loading的效果。

用空间换时间，当类加载的时候就创建类的实例，不管你用不用，先创建出来

public class Singleton {
    //2.本类内部创建对象实例
 private  static Singleton instance=new Singleton();
 /*
 * 1.构造方法私有化，外部不能new*/
 private Singleton(){
    }
    //3.提供一个公有的静态方法，返回实例对象
 public static Singleton getInstance(){
       
        return instance;
 }
}

5.饿汉式（变种，静态代码块）
静态代码块：用staitc声明，jvm加载类时执行，仅执行一次
构造代码块：类中直接用{}定义，每一次创建对象时执行。
执行顺序：静态代码块>main()主方法>构造代码块>构造方法

public class Singleton {
    //2.本类内部创建对象实例
 private  static Singleton instance=null;
 static {
        instance=new Singleton();//即在类初始化实例化instance
 }
    /*
 * 1.构造方法私有化，外部不能new*/
 private Singleton(){
    }
    //3.提供一个公有的静态方法，返回实例对象
 public static Singleton getInstance(){
        return instance;
 }
}

6.单例（静态内部类）
这种方式同样利用了classloder的机制来保证初始化instance时只有一个线程，它跟第四种和第五种方式不同的是（很细微的差别）：第四种和第五种方式是只要Singleton类被装载了，那么instance就会被实例化（没有达到lazy loading效果），而这种方式是Singleton类被装载了，instance不一定被初始化。因为SingletonHolder类没有被主动使用，只有显示通过调用getInstance方法时，才会显示装载SingletonHolder类，从而实例化instance。想象一下，如果实例化instance很消耗资源，我想让他延迟加载，另外一方面，我不希望在Singleton类加载时就实例化，因为我不能确保Singleton类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化instance显然是不合适的。这个时候，这种方式相比第四种和第五种方式就显得很合理。

//推荐这种写法
public class Singleton {
    private static class SingletonHoler{
        /*
 * 2.静态初始化器，由JVM来保证线程安全*/
 private static final Singleton instance=new Singleton();
 }
    /*
 * 1.构造方法私有化，外部不能new*/
 private Singleton(){
    }
    //3.提供一个公有的静态方法，返回实例对象
 public static Singleton getInstance(){
        return SingletonHoler.instance;
 }
}

结尾：学而不思则罔，思而不学则殆