1.单例模式

1、设计模式是一套代码设计经验的总结。项目中合理的运用设计模式可以巧妙的解决很多问题

2、总体来说设计模式分为三大类：

        1）创建型模式

                工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式

        2）结构型模式

                适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式

        3）行为型模式

                策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、

                备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

3、设计模式的六大原则

1）开闭原则（Open Close Principle）

开闭原则的意思是：对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。简言之，是为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类。

2）里氏代换原则（Liskov Substitution Principle）

里氏代换原则是面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。LSP 是继承复用的基石，只有当派生类可以替换掉基类，且软件单位的功能不受到影响时，基类才能真正被复用，而派生类也能够在基类的基础上增加新的行为。里氏代换原则是对开闭原则的补充。实现开闭原则的关键步骤就是抽象化，而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。

3）依赖倒转原则（Dependence Inversion Principle）

这个原则是开闭原则的基础，具体内容：针对接口编程，依赖于抽象而不依赖于具体。

4）接口隔离原则（Interface Segregation Principle）

这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。它还有另外一个意思是：降低类之间的耦合度。由此可见，其实设计模式就是从大型软件架构出发、便于升级和维护的软件设计思想，它强调降低依赖，降低耦合。

5）迪米特法则，又称最少知道原则（Demeter Principle）

最少知道原则是指：一个实体应当尽量少地与其他实体之间发生相互作用，使得系统功能模块相对独立。

6）合成复用原则（Composite Reuse Principle）

合成复用原则是指：尽量使用合成/聚合的方式，而不是使用继承。

4、小应用也能体现大原则

5、单例模式是Java中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式

6、单例模式确保在一个应用程序中某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例单例实例。单例模式只应在有真正的“单一实例”的需求时才可使用：

1）单例类只能有一个实例

2）单例类必须自己创建自己的唯一实例

3）单例类必须给所有其他对象提供这一实例

7、Java中实现单例模式可以通过两种形式实现：

懒汉模式（类加载时不初始化）

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

8、编写单例必要条件：

1）构造方法变成私有

2）提供一个静态方法获取单实例对象

饿汉单例相对比较容易理解，一般表现为以下两种形式：

//构造方法私有化
private static Singleton1 instance = new Singleton1();
private Singleton1() {
}


//静态代码块的方式，实例化对象
private static Singleton1 instance = null;
static {
    instance = new Singleton1();
}

构造方法私有化为例: 

/**
 * 饿汉式单例1
 */
public class Singleton1 {
    //static保证全局唯一
    private static Singleton1 instance = new Singleton1();

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    //构造方法私有化
    private Singleton1() {
    }

    //提供一个静态方法返回实例对象
    public static Singleton1 getInstance() {
        //不能保证下面代码getInstance方法调用一次，就会获取一个新对象，不能达到单例目的
        //return new Singleton1();
        //instance就是全局唯一
        return instance;
    }

    public void sayHello() {
        System.out.println("我是博肖女孩");
    }
}

public class SingletonTest {
    public static void main(String[] args) {
        //Singleton1私有的构造方法，不能在外部new
        //Singleton1 s1=new Singleton1();

        Singleton1 instance1 = Singleton1.getInstance();
        Singleton1 instance2 = Singleton1.getInstance();
        //static全局唯一，设为static后值为true
        System.out.println(instance1 == instance2);
        instance1.sayHello();
        instance1.setName("博肖");
        System.out.println(instance1.getName());
        System.out.println(instance2.getName());
    }
}

 9、饿汉模式基于classloader机制避免了多线程的同步问题（静态初始化将保证在任何线程能够访问到域之前初始化它），不过，instance在类装载时就实例化，这时候初始化instance显然没有达到lazy loading的效果

10、懒汉方式实现单例模式能够提高类加载性能，但是和饿汉模式借助与JVM的类加载内部同步机制实现了线程安全不同，需要在延迟加载时注意单例实例的线程安全性，如果简单粗暴的实现，在多线程环境中将引起运行异常，如：

/**
 * 懒汉式: 多线程, 有问题
 */
public class Singleton3 {
    //单例实例
    private static Singleton3 instance;

    //构造方法私有化
    private Singleton3() {

    }

    //提供一个静态方法,获取单例的实例对象
    public static Singleton3 getInstance() {
        //如果instance为null，就创建一个实例对象，不为null，直接返回不再创建。
        if (instance == null) {
            instance = new Singleton3();
        }
        return instance;
    }

    public static void satHello() {
        System.out.println("调用了Singleton3的sayHello的静态方法");
    }

    public void say() {
        System.out.println("调用了Singleton3的say的实例方法");
    }
}

/**
 * 多线程不一定是单例,new多个对象,对象不同
 * 多线程不稳定,DeBug断点模拟
 */
public class Singleton3Test {
    public static void main(String[] args) {
        Singleton3.satHello();//不用调用实例
        //子线程调用getInstance方法
        Thread t = new Thread(() -> {
            Singleton3 instance1 = Singleton3.getInstance();
            instance1.say();
            System.out.println("线程t的对象:" + instance1);
        });
        t.start();

        Thread t1 = new Thread(() -> {
            Singleton3 instance1 = Singleton3.getInstance();
            instance1.say();
            System.out.println("线程t1的对象:" + instance1);
        });
        t1.start();

        //主线程调用getInstance方法
        Singleton3 instance2 = Singleton3.getInstance();
        instance2.say();//调用实例
        System.out.println("主线程main的对象:" + instance2);
    }
}

单线程： 

public class SingletonTestThread {
    public static void main(String[] args) {
        Singleton3 instance1 = Singleton3.getInstance();
        Singleton3 instance2 = Singleton3.getInstance();
        System.out.println("instance1的对象：" + instance1);
        System.out.println("instance2的对象：" + instance2);
    }
}

上述代码多线程同时访问时可能会产生多个示例，甚至会破坏实例，违背单例的设计原则

11、可以为返回单例实例的方法设置同步用来保证线程安全性

/**
 * 懒汉式:多线程安全单例  方式一
 * 效率问题
 */
public class Singleton4 {
    private static Singleton4 instance;

    private Singleton4() {
    }

    //synchronized 静态方法, 锁住的Singleton4的字节码, 因为字节码是全局唯一的.
    //synchronized 静态方法, 可以解决多线程情况, 保证创建的对象是唯一的.
    public synchronized static Singleton4 getInstance() {
        if (instance == null) {
            instance = new Singleton4();
        }
        return instance;
    }

    public void say() {
        System.out.println("调用了Singleton3的say的实例方法");
    }
}

/**
 * 懒汉式
 */
public class Singleton4Test {
    public static void main(String[] args) {
        //子线程调用getInstance方法
        Thread t = new Thread(() -> {
            Singleton4 instance1 = Singleton4.getInstance();
            instance1.say();
            System.