设计模式

单例模式

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

饿汉式(静态常量)

• 构造器私有化
• 类的内部创建对象
• 向外暴露一个静态的公共方法

/**
 * 饿汉式(静态常量)
 */
public class Singleton01 {
    public static void main(String[] args) {
        //测试
        Singleton instance = Singleton.getInstance();
    }
}
class Singleton{
    //1 构造器私有化
    private Singleton(){
    }
    //2 本类内部创建对象实例
    private final static Singleton instance = new Singleton();
    //3 提供一个公有的静态方法，返回实例对象
    public static Singleton getInstance(){
        return instance;
    }
}

• 优点
  • 写法比较简单，就是在类装载的时候就完成实例化。避免了下城同步问题
• 缺点
  • 在类装载的时候就完成实例化，没有达到lazy loading的效果。如果从始至终都没用过这个实例，则会造成内存的浪费。
• 这种方式基于classloader机制避免了多线程的同步问题，不过，instance在装载就实例化，在单例模式中大多数都是调用getInstace方法，但是导致类装载的原因有很多种，因此不能确定有其他方式（或其他静态方法）导致类装载，这时候初始化instance就没有达到lazy loading的效果
• 这种单例模式可用，可能造成内存浪费

饿汉式(静态代码块)

/**
 * 饿汉式(静态代码块)
 */
public class Singleton02 {
    public static void main(String[] args) {
        //测试
        Singleton instance = Singleton.getInstance();
        Singleton instance1 = Singleton.getInstance();
        System.out.println(instance.hashCode() == instance1.hashCode());
    }
}
class Singleton{
    //1 构造器私有化
    private Singleton(){
    }
    //2 本类内部创建对象实例
    private  static Singleton instance;
    //在静态代码块种创建对象实例
    static {
        instance = new Singleton();
    }
    //3 提供一个公有的静态方法，返回实例对象
    public static Singleton getInstance(){
        return instance;
    }
}

• 静态代码块和静态常量类似，只不过将类实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例。优缺点和上面是一样的。
• 这种单例模式可用，但是可能造成内存浪费

懒汉式(线程不安全)

/**
 * 懒汉式(线程不安全)
 */
public class Singleton03 {
    public static void main(String[] args) {
        //测试
        Singleton instance = Singleton.getInstance();
        Singleton instance1 = Singleton.getInstance();
        System.out.println(instance.hashCode() == instance1.hashCode());
    }
}
class Singleton{
    private static Singleton instance;
    private Singleton(){
    }
    //提供静态的公用方法，当使用该方法时，才创建实例
    public static Singleton getInstance(){
        if (instance == null){
            instance = new Singleton();
        }
        return instance;
    }
}

• 起到了lazy loading的效果，但是只能在单线程下使用
• 在多线程下，一个线程进入了if(instance == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时会产生多个实例
• 在实际开发中，不能使用这种方式

懒汉式(线程安全)

/**
 * 懒汉式(线程安全，同步方法)
 */
class Singleton{
    private static Singleton instance;
    private Singleton(){
    }
    //使用synchronized解决线程安全问题
    public static synchronized Singleton getInstance(){
        if (instance == null){
            instance = new Singleton();
        }
        return instance;
    }
}

• 解决了线程不安全问题
• 效率太低了，每个线程在向获得类的实例的时候，执行getInstance()都要进行同步。而其实这个方法只执行一个实例化代码就够了，后面的想获得该类实例直接return就行了
• 在实际开发中不推荐使用这种方法

双重检查

/**
 * 双重检查
 */
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(singleton == null)检查，这样就可以保证线程安全了
• 实例化代码只用执行一次，后面再次访问直接return实例化对象
• 线程安全；延迟加载；效率较高
• 在实际开发中，推荐使用这种单例设计模式

静态内部类

/**
 * 静态内部类
 */
class Singleton{
    private static volatile Singleton instance;
    private Singleton(){
    }
    //静态内部类
    //Singleton类装载的时候内部类不会装载
    //类装载是线程安全的
    private static class SingletonInstance{
        private static final  Singleton instance = new Singleton();
    }
    public static  Singleton getInstance(){
        return SingletonInstance.instance;
    }
}

• 这种方式采用了类装载机制来保证初始化实例时只有一个线程
• 静态内部类方式在Singleton类被状态时并不会立即实例化，而是在需要实例化时，调用getInstance()，才会装载SingletonInstance类，从而完成Singleton的实例化
• 类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程无法进入的。
• 在实际开发中，推荐使用

枚举

public class Singleton07 {
    public static void main(String[] args) {
        //测试
        Singleton instance = Singleton.INSTANCE;
        Singleton instance1 = Singleton.INSTANCE;
        System.out.println(instance.hashCode() == instance1.hashCode());
    }
}
/**
 * 枚举
 */
enum  Singleton{
    INSTANCE;
}