单例模式（singleton）

单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，它提供全局访问的方法。

一是某个类只能有一个实例；
二是它必须自行创建这个实例；
三是它必须自行向整个系统提供这个实例。

单例模式是一种对象创建型模式。

饿汉式：在类加载的时候就会自动创建，多线程访问下也可以正常运行

public class HungryType {
    private static final HungryType instance = new HungryType();
    
    private HungryType(){
    }
    
    public static HungryType GetInstance()
    {
        return instance;
    }
    public static void main(String[] args) throws NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
        HungryType ht =    HungryType.GetInstance();
        Class<?> classType=HungryType.class;
        //通过反射机制调用私有的构造器。
        Constructor<?> c = classType.getDeclaredConstructor();
        c.setAccessible(true);
        HungryType newht=(HungryType)c.newInstance();
        System.out.println(ht==newht);
    }
}

懒汉式：好处就是延时加载，在需要的时候再加载

普通懒汉式：

public class SluggardType {
    private static SluggardType instance = null;    
    private SluggardType() {
    
    }  
    public static SluggardType getInstance(){
        if(instance == null){
            instance = new SluggardType();
        }
        return instance;
    }  
}

在多线程访问的情况下，可能会执行多次new的操作双重检验锁的方式来改进：

这里为什么需要两个判空，仅仅最里面的一层，在多线程的情况下，就会创建多个实例，因此在外面加了一层锁，但是这样所有的线程来的时候都会进入临界区再出来，导致大量线程阻塞，影响性能，因此我们在外面再加一层判空，在实例创建以后既不会进入临界区等待了。

public class SluggardType {
    private volatile static SluggardType instance = null;    
    private SluggardType() {
    
    }  
    public static SluggardType getInstance(){
        if(instance == null){
            synchronized(SluggardType.class){
                if(instance==null)
                   instance = new SluggardType();
            }       
        }
        return instance;
    } 
}

上面这张双重校验锁是我们用到的最多的情况，我们通过这个例子再来理解一些volatile关键字。

假如这里不加volatile关键字会怎么样？

线程A执行instance = new SluggardType()的时候会发生指令重排，分配内存空间以后，就变量直接指向内存空间（这个时候并没有初始化对象）

线程B执行的时候判断instance不为空，就直接返回，实际上这个时候instance并没有完成初始化。

下面这种方案可以不用volatile关键字

通过静态内部类的方式来实现单例模式，同时解决了多线程访问的问题

public class InnerClassSingleton {
    //静态内部类的实例与外部的实例没有关系，可以等到用的时候再加载，而且只会被加载一次
    private static class SingletonHolder {
        private static InnerClassSingleton instance = new InnerClassSingleton();
    }
    private InnerClassSingleton() {
    }
    //延时操作并没有增加任何访问成本
    public static InnerClassSingleton getInstance() {
        return SingletonHolder.instance;
    }
}

 

！但是以上的所有情况都可以通过反射来破坏我们的单例模式

因此就有了通过枚举来实现单例模式

public enum EnumSingleton {

    INSTANCE;
    //枚举实现的单例模式就可以保证我们的构造函数只会被执行一次
    private EnumSingleton() {
        
    }  
    public void test() {
        System.out.println("test");
    }
    public static void main(String[] args) throws NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
        Class<?> classType=EnumSingleton.class;
        //通过反射机制调用私有的构造器。
        Constructor<?> c = classType.getDeclaredConstructor();
        c.setAccessible(true);
        EnumSingleton newes=(EnumSingleton)c.newInstance();
        newes.test();//以上会报错抛出异常
        EnumSingleton es=EnumSingleton.INSTANCE;
        es.test();   //输出test
    }
}

 

转载于:https://www.cnblogs.com/smallJunJun/p/9373774.html