单例模式

什么是单例

单例模式就是确保一个类只有一个实例，并且为整个系统提供一个全局访问点的一种方法。

单例模式的主要特点

• 构造方法私有化
• 实例化的变量引用私有化
• 获取实例的方法公有化

单例模式的5种创建方式

• 饿汉式
• 懒汉式
• 静态内部类方式
• 双重检测方式
• 枚举实现方式

1. 饿汉式

public class HungrySingleton {
    //定义一个静态私有的变量，直接在这里创建好类实例，只会创建一次
    private static HungrySingleton uniqueInstance = new HungrySingleton();
    //构造方法私有化，只能在本类中实例化，控制实例化的数目
    private HungrySingleton(){}
    //定义一个方法为客户端提供实例
    public static HungrySingleton getInstance(){
        return uniqueInstance;
    }
    //可以有自己的成员变量
    private String singletonData;
    public String getSingletonData(){
        return singletonData;
    }
    //可以有自己的方法
    public void singletonOperation(){}
}

饿汉式既能保证单例又能保证线程安全：类加载的方式是按需加载，且只加载一次，因此在上述单例类被加载时，就会实例化一个对象并交给自己的引用，供系统使用。因此该实例类只会创建一个实例从而实现单例。而且饿汉式是天生线程安全的，因为由JVM保证线程安全。
饿汉式缺点：饿汉式初始化的时候就会加载该对象，调用效率高，所以响应的就会占用一定内存，典型的用空间换时间。

2. 懒汉式

public class LazySingleton {
    //定义一个私有的静态的变量存储创建好的实例
    private static LazySingleton uniqueInstance = null;
    //定义一个私有的构造器，让外界不能new,在内部可以控制实例的数目
    private LazySingleton(){}
    //定义一个静态方法让外界使用该实例（为什么使用静态公共方法？？静态是为了可以访问静态变量）
    public static LazySingleton getInstance(){
        //判断存储的实例是否有值
        if (uniqueInstance == null){
            //如果没有，就创建出来，并用静态变量存储
            uniqueInstance = new LazySingleton();
        }
        //如果存在，直接返回
        return uniqueInstance;
    }
    //可以定义自己的方法
    public void  singletonOperation(){}
    //可以定义自己的私有成员变量并直接返回，让外界可以访问该成员变量
    public String singletonData;
    public String getSingletonData(){
        return singletonData;
    }
}

懒汉式保证了单例：懒汉式对象到真正需要的时候才会被创建，且一旦创建出来就不会再创建
懒汉式缺点：懒汉式是非线程安全的。new LazySingleton()在创建实例时，还未创建成功，此时 if (uniqueInstance == null)判断为true也能进入，此时线程是不安全的。
使用synchronized修饰getInstance方法虽然可以实现线程安全，但是效率非常低。

3. 静态内部类单例

public class LazyInitialization {
    //创建内部静态类，只有在被调用的时候才会被创建，而且jvm实现了线程安全
    private static class SingletonHolder{
        private static LazyInitialization instance = new LazyInitialization();
    }
    //私有构造方法
    private LazyInitialization(){}
    //定义可以让客户端进行获取该实例的方法
    public static LazyInitialization getInstance(){
        return SingletonHolder.instance;
    }
}
    
     //可以定义自己的方法
    public void  singletonOperation(){}
    //可以定义自己的私有成员变量并直接返回，让外界可以访问该成员变量
    public String singletonData;
    public String getSingletonData(){
        return singletonData;
    }
}

静态内部类可以保证单例，也可以保证线程安全：当getInstance方法第一次被调用的时候，它第一次读取SingletonHolder.instance导致SingletonHolder类得到初始化；而这个类在装载并被初始化的时候会初始化它的静态域，从而创建Singleton的实例，由于是静态的，只会在虚拟机中初始化一次，由虚拟机保证线程安全。

4.双重检测创建单例

public class VolatileSingleton {
    private VolatileSingleton(){}
    private static volatile VolatileSingleton uniqueInstance;
    public static VolatileSingleton getInstance(){
        if (uniqueInstance == null){
            synchronized (VolatileSingleton.class){
                if (uniqueInstance == null)//....................................1
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    uniqueInstance = new VolatileSingleton();//..................2
                }															  
            }
        }
        return uniqueInstance;//.................................................3
    }
    
    //自己的方法和成员变量
    public void singletonOperation(){}
    private String singletonData;
    public String getSingletonData(){
        return singletonData;
    }
}

重排序：
代码2处可分为三行伪代码：
①memory = allocate();//分配对象的内存空间
②initInstance(memory);//初始化对象
③uniqueInstance = memory;//设置instance指向刚分配的地址

多线程情况下②③代码可能会发生重排序，即②③代码交换，此时线程B在1处判断uniqueInstance不为null，直接返回一个未初始化的对象。使用volidate后重排序在多线程的情况下就会被禁止，就不会出现返回未初始化对象的情况。

双重检测创建单例可以实现单例的同时实现高效率同步：为了保证单例前提下提高运行效率，我们需要对VolatileSingleton 进行第二次检查，目的是避开过多地同步（这里的同步只需要在第一次创建的时候同步，一旦创建成功，以后获取实例就不用同步获取锁来了）

5.枚举类创建单例

public enum Enum Singleton{
	INSTANCE;
	puiblic EnumSingleton getInstance(){
			return INSTANCE;
	}
}

枚举类创建单例主要解决了反射攻击和序列化问题。