设计模式----单例模式（创建型）

设计模式的六大基本原则

1. 单一职责原则 (Single Responsibility Principle)

   一个类只负责一项职责。

2. 接口隔离原则 (Interface Segregation Principle)

   将一个功能比较杂的接口拆成多个接口。

3. 依赖倒置原则 (Dependence Inversion Principle)

   面向接口编程，抽象不依赖实现。比如让一个方法的参数类型变为接口，然后传其实现类就可实现不同的功能。

4. 里氏替换原则 (Liskov Substitution Principle)

       1、子类尽量不要重写父类的方法。  2、继承实际上会破坏封装，因为继承将基类的实现细节暴露给子类；如果基类的实现发生了改变，则子类的实现也不得不改变。适当情况下，可以让两个类继承更高的父类，然后通过组合聚合依赖的方式避免继承。

5. 开闭原则 (Open-Closed Principle)

   尽可能地不要修改已经写好的代码或已有的功能，而是去扩展它。

6. 迪米特法则（Law Of Demeter）

   对象之间减少不必要的依赖。也就是说，陌生的类最好不要作为局部变量的形式出现在类的内部，除了形参。

单例模式

        单例模式是比较常见的一种设计模式，目的是保证一个类只能有一个实例，而且自行实例化并向整个系统提供这个实例，避免频繁创建对象，节约内存。

        在程序编写上，一般将单例模式分为两种，分别是饿汉式和懒汉式。

        饿汉式：在类加载时就完成了初始化，所以类加载比较慢，但获取对象的速度快。

        懒汉式：在类加载时不初始化，等到第一次被使用时才初始化。

         还有双重检查锁实现、静态内部类实现、枚举实现

饿汉式:

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

    //私有化构造方法
    private Singleton(){}
 
    public static Singleton getInstance(){
        return instance;
    }
 
}

懒汉式:

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

}

        如果是在多线程的场景下就不能使用上面这张方式了。假设对象还没被实例化，然后有两个线程同时访问，那么就可能出现多次实例化的结果。可以让实例方法进行同步,代码如下:

public class Singleton {
 
    private static Singleton instance = null;
    //私有化构造方法，外部无法直接 new 来创建该类
    private Singleton() {
    }

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


    //方法二
    public static Singleton getInstance1(){
          if (instance == null) {
            synchronized (Singleton.class) {
                 instance = new Singleton();  
            }
        }
        return instance;
    }

 
}

        方法一的“粒度”较大，方法二的“粒度”较小

        方法一这种写法是对getInstance()方法加了锁的处理，保证了同一时刻只能有一个线程访问并获得实例，但是缺点也很明显，因为synchronized是修饰整个方法，每个线程访问都要进行同步，而其实这个方法只执行一次实例化代码就够了，每次都同步方法显然效率低下，为了改进这种写法，就有了方法二，但是方法二这种方法也存在缺陷，如果同时多个线程都进入if方法时，还是会多次创建实例对象，就得使用如下的双重检测锁:

static class Singleton {
   //私有化构造方法，外部无法直接 new 来创建该类
    private Singleton() {}
    private static Singleton instance = null;
 
    public static Singleton getInstance() {
        if(instance == null){
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}