《设计模式》设计模式的基本原则
 《设计模式》单例模式
 《设计模式》工厂模式
 《设计模式》原型模式
 《设计模式》建造者模式
 《设计模式》适配器模式
 《设计模式》桥接模式
 《设计模式》装饰者模式
 《设计模式》组合模式
 《设计模式》外观模式
 《设计模式》享元模式
 《设计模式》代理模式
 《设计模式》模板方法模式
 《设计模式》命令模式

《设计模式》单例模式

1. 饿汉式
2. 懒汉式
3. 双重检查
4. 静态内部类
5. 枚举

定义：单例设计模式就是
采取一定的方法保证在整个软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法（静态方法）。

单例模式的注意事项：

由于单例模式保证了系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建和销毁的对象，使用单例模式可以提高系统性能。
想要实例化一个单例类的时候，通过相应的获取对象的方法，而不是使用 new 关键字。

使用场景：

频繁进行创建和销毁的对象
创建对象时耗时过多或耗费资源过多（重量级对象），但又经常用到的对象
工具类对象
频繁访问数据库或文件的对象（数据源、session 工程）

单例模式有五种实现方式：

饿汉式
懒汉式
双重检查
静态内部类
枚举

1. 饿汉式

实施步骤：

首先，将构造器私有化，防止创建实例
然后，在类的内部创建对象
最后，向外暴露一个静态的公共方法 getInstance()

1、静态变量方式

class Singleton {

    //构造器私有化
    private Singleton() {}

    //本类内部创建类实例，在类加载准备阶段完成
    private final static Singleton instance = new Singleton();

    //提供一个公有的静态方法，返回实例对象
    public static Singleton getInstance() {
        return instance;
    }
}

2、静态代码块方式

class Singleton {

    //构造器私有化
    private Singleton() { }

    //在静态代码块中创建单例对象，静态代码块中的代码在类初始化阶段完成
    static {
        instance = new Singleton();
    }

    //本类内部创建对象实例
    private static Singleton instance;

    //提供一个公有的静态方法，返回实例对象
    public static Singleton getInstance() {
        return instance;
    }
}

饿汉式单例模式的优缺点：

优点：写法简单，基于类加载机制避免了多线程的同步问题。
缺点：如果一直都没有使用过该实例，则会造成内存浪费。

2. 懒汉式

1、线程不安全的懒汉式单例模式

class Singleton {
    private static Singleton instance;

    private Singleton() {}

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

线程不安全懒汉式的优缺点：

优点：起到了懒加载的效果，不会造成内存不必要的浪费。
缺点：只能在单线程环境下使用，多线程环境使用会因为线程不安全，创建多个实例。

2、线程安全的懒汉式单例模式

class Singleton {
    private static Singleton instance;

    private Singleton() {}

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

线程安全懒汉式的优缺点：

优点：使用同步锁解决了线程安全问题。
缺点：每个线程在想获得类的实例时，执行 getInstance() 方法都要进行同步，方法同步效率太低。

3. 双重检查

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

    //加入双重检查代码，解决线程安全问题和懒加载问题,同时保证效率
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

双重检查的优点：

双重检查保证了线程安全，同时也实现了懒加载，实例化代码只执行一次，后面再访问时，判断 if (instance == null) 直接返回实例化对象，也避免了反复进行方法同步。
实际开发中推荐使用双重检查。

4. 静态内部类

class Singleton {
	//类的静态属性只有在第一次加载类的时候才会初始化，JVM保证了线程的安全性，在类进行初始化时
	//别的线程无法进入
    private static volatile Singleton instance;

    private Singleton() {}
    
    //Singleton加载时静态内部类不会立即实例化，只有在需要实例化时调用getInstance方法
    //才会装在SingletonInstance类，从而完成Singleton的实例化
    private static class SingletonInstance {
        private static final Singleton INSTANCE = new Singleton();
    }

    //JVM在加载类时是线程安全的，通过静态内部类只加载一次，保证只创建一次外部类的实例
    public static Singleton getInstance() {
        return SingletonInstance.INSTANCE;
    }
}