设计模式之单例模式

单例模式

单例模式是设计模式中使用最为普遍的模式之一。它是一种对象创建模式，用于产生一个对象的具体实例，它可以确保系统中一个类只产生一个实例。在Java中，这样的行为能带来两大好处。

• (1)对于频繁使用的对象，可以省略new操作花费的时间，这对于那些重量级对象而言，是非常可观的一笔系统开销。
• (2)由于new操作的次数减少，因而对系统内存的使用频率也会降低，这将减轻GC压力，缩短GC停顿时间。

单例模式最重要一点，构造方法私有。

单例模式要解决的就是系统开销的问题

常见场景：

• Windows的任务管理器
• Windows的回收站
• 项目中，读取配置文件的类，一般也只有一个对象， 没必要每次都去new对象读取
• 网站的计数器一般也会采用单例模式，可以保证同步
• 数据库连接池的设计一般也是单例模式
• 在Servlet编程中，每个Servlet也是单例的
• 在Spring中，每个Bean默认就是单例的（单例是饿汉式创建）

1. 饿汉式

package com.wlw.single;
/**
 * 饿汉式
 * 类加载时创建，天生线程安全，但是 声明周期太长，浪费空间
 */
public class Hungry {

    //饿汉式单例，类加载时就创建,如果有下面类似的代码，就会浪费空间
    private byte[]  data1 = new byte[1024*1024];
    private byte[]  data2 = new byte[1024*1024];
    private byte[]  data3 = new byte[1024*1024];
    private byte[]  data4 = new byte[1024*1024];

    private Hungry(){}
    private static final Hungry hungry = new Hungry();
    public static Hungry getInstance(){
        return hungry;
    }
}

这个单例的性能是非常好的，由于getInstance()方法只是简单地返回hungry，并没有任何锁操作，因此它在并行程序中会有良好的表现。

但是这种方式有一个明显不足就是Hungry构造函数，或者说Hungry实例在什么时候创建是不受控制的。对于静态成员hungry，它会在类第一次初始化的时候被创建。这个时刻并不一定是getInstance()方法第一次被调用的时候。

比如，如果你的单例像是这样的:

package com.wlw.single;
public class Hungry {
	public static int STATUS = 1;
    private Hungry(){System.out.println("Hungry is create");}
    private static final Hungry hungry = new Hungry();
    public static Hungry getInstance(){
        return hungry;
    }
}

注意，这个单例还包含一个表示状态的静态成员STATUS。此时，在任何地方引用这个STATUS都会导致hungry实例被创建(任何对Hungry这个类里的方法或者字段的引用，都会导致类初始化，并创建hungry实例，但是类初始化只有一次，因此hungry实例永远只会被创建一次)，比如在这样的情况下，某一行代码用到了静态成员STATUS：

System.out.println (Singleton.STATUS);

当执行了这行代码，就会输出：

Hungry is create
1

可以看到，即使系统没有要求创建单例，new Hungry()方法也会被调用。

如果大家觉得这个小小的不足并不重要，那么这种单例模式也是一种不错的选择。它容易实现，代码易读而且性能优越。

但如果你想精确控制hungry的创建时间，那么这种方式就不太友善了。我们需要寻找一种新的方法，一种支持延迟加载的策略，它只会在第一次真正使用hungry时才创建对象，这种方法就是下面的懒汉式。

2.普通懒汉式

package com.wlw.single;

/**
 * 懒汉式单例
 * 使用时创建，声明周期短，节省空间 ，但线程不安全，（可通过同步方法与同步代码块来改善）
 */
public class Lazy {
    private Lazy(){
        System.out.println(Thread.currentThread().getName()+"==> ok");
    }
    private static Lazy lazy ;

    //提供公共的获取方法,因为不是在类加载时就创建对象，因此存在线程安全问题，使用synchronized关键字保证线程安全，效率降低
    public static synchronized Lazy getInstance(){
        if(lazy == null){
            lazy = new Lazy();	
        }
        return lazy;
    }

    //多线程操作,单例模式，就是只会有一个实例，而此时却有不定个，所以需要对getInstance方法加锁处理
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                Lazy.getInstance();
            }).start();
        }

    }
}

核心思想是：最初，我们并不需要实例化lazy，而当getInstance()方法被第一次调用时，创建单例对象。为了防止对象被多次创建，我们不得不使用synchronized关键字进行方法同步。这种实现的好处是，充分利用了延迟加载，只在真正需要时创建对象。但坏处也很明显，并发环境下加锁，竞争激烈的场合对性能可能产生一定的影响。但总体上，这是一个非常易于实现和理解的方法。

3. DCL懒汉式(双重检测锁模式)

这种方式，并不推荐，我认为它是一个比较复杂而且有点丑陋的方法，但是如果是用来学习volatile关键字，倒是一个不错的例子。

package com.wlw.single;

/**
 * 懒汉式单例
 * 使用时创建，声明周期短，节省空间 ，但线程不安全，（可通过同步方法与同步代码块来改善）
 */
public class Lazy {
    private Lazy(){
        System.out.println(Thread.currentThread().getName()+"==> ok");
    }
    private volatile static Lazy lazy ;
/*
    //提供公共的获取方法,因为不是在类加载时就创建对象，因此存在线程安全问题，使用synchronized关键字保证线程安全，效率降低
    public static synchronized Lazy getInstance(){
        if(lazy == null){
            lazy = new Lazy();
        }
        return lazy;
    }

 */

    //双重检索锁模式的 懒汉式单例， DCL懒汉式
    //同样是在类加载时只提供一个引用，不会直接创建单例对象，不需要对整个方法进行同步，缩小了锁的范围，只有第一次会进入创建对象的方法，提高了效率
    public static Lazy getInstance(){
        if(lazy == null){  //这一句是为了提高执行效率，不用每次都判断锁
            synchronized (Lazy.class){ // 这个锁只有一个，因为Lazy.class只有一个
                if(lazy == null){
                    lazy = new Lazy(); //new 操作不是一个原子操作
                    /**
                     * 1. 分配内存空间
                     * 2、执行构造方法，初始化对象
                     * 3、把这个对象指向这个空间
                     *
                     * 我们希望是按照 123 走
                     * 但是可能出现 按照 132
                     * 假如线程A进来按照132走，走到3时，线程B进来发现已经有一个对象指向了一个空间，就认为此时lazy！=null，
                     * 所以，B就会直接走  return lazy; 而此时线程A中的Lazy还没有完成构造，就会出错。
                     * 这样的问题是有指令重排造成的，所以我们可以加上 Volatile 来禁止指令重排
                     */
                }
            }
        }
        return lazy;
    }


    //多线程操作,单例模式，就是只会有一个实例，而此时却有不定个，所以需要对getInstance方法加锁处理
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                Lazy.getInstance();
            }).start();
        }

    }
}

4. 静态内部类懒汉式

package com.wlw.single;

//静态内部类懒汉式
//使用静态内部类解决了线程安全问题，并实现了延时加载
public class Holder {
    private Holder(){}

    //不会在外部类初始化时就直接加载，只有当调用了getInstance方法时才会静态加载，线程安全，final保证了在内存中只有一份
    private static class InnerClass{
        private static final Holder hodler  = new Holder();
    }

    public static Holder getInstance(){
        return InnerClass.hodler;
    }
}

这种方式，结合了饿汉式与普通懒汉式二者的优势，首先getInstance()方法中没有锁,这使得在高并发环境下性能优越（饿汉式的优点）。其次，只有在getInstance()方法第一次被调用时，Holder的实例才会被创建，充分利用了延迟加载。

因为这种方法巧妙地使用了内部类和类的初始化方式。内部类InnerClass被声明为private，这使得我们不可能在外部访问并初始化它。而我们只可能在getInstance()方法内部对InnerClass类进行初始化，利用虚拟机的类初始化机制创建单例。

5.枚举单例

• 以上的单例模式是不安全的，可以用反射来破坏

• 我们怎么解决呢？我们来看一下反射中的newInstance()方法 （枚举不能使用反射来破坏）

  

• 枚举单例

package com.wlw.single;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

//enum 是什么？ enum本身就是一个Class 类
//枚举方式实现单例模式
public enum  EnumSingle {
    INSTANCE;

    public EnumSingle getInstance(){
        return INSTANCE;
    }
}

class Test{
    public static void main(String[] args) throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        EnumSingle instance = EnumSingle.INSTANCE;

        Constructor<EnumSingle> declaredConstructors = EnumSingle.class.getDeclaredConstructor(null);
        //报错 Exception in thread "main" java.lang.NoSuchMethodException: com.wlw.single.EnumSingle.<init>() 没有空参方法
        //如果我们看idea 编译后的文件：会发现idea骗了我们，居然告诉我们是有无参构造的，我们使用jad进行反编译。
        
        declaredConstructors.setAccessible(true); //破坏私有权限
        EnumSingle instance2 = declaredConstructors.newInstance();
        System.out.println(instance);
        System.out.println(instance2);

    }
}

• 如果我们看idea 编译后的文件：会发现idea骗了我们，居然告诉我们是有无参构造的，我们使用jad进行反编译。

package com.wlw.single;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

//enum 是什么？ enum本身就是一个Class 类
//枚举方式实现单例模式
public enum  EnumSingle {
    INSTANCE;

    public EnumSingle getInstance(){
        return INSTANCE;
    }
}

class Test{
    public static void main(String[] args) throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        EnumSingle instance = EnumSingle.INSTANCE;

        //Constructor<EnumSingle> declaredConstructors = EnumSingle.class.getDeclaredConstructor(null);
        //报错 Exception in thread "main" java.lang.NoSuchMethodException: com.wlw.single.EnumSingle.<init>() 没有空参方法
        //如果我们看idea 编译后的文件：会发现idea骗了我们，居然告诉我们是有无参构造的，我们使用jad进行反编译。

        //反编译之后，我们看见一个 有参构造 ，两个参数为 String ，int 类型
        Constructor<EnumSingle> declaredConstructors = EnumSingle.class.getDeclaredConstructor(String.class,int.class);
        // 此时报的错是：Exception in thread "main" java.lang.IllegalArgumentException: Cannot reflectively create enum objects
        // 提醒我们不能用反射破坏枚举
        declaredConstructors.setAccessible(true); //破坏私有权限
        EnumSingle instance2 = declaredConstructors.newInstance();
        System.out.println(instance);
        System.out.println(instance2);

    }
}