单例模式大全

饿汉式

// 饿汉式单例
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 final static Hungry HUNGRY = new Hungry();
    public static Hungry getInstance(){
        return HUNGRY;
    }
}

优点： 无同步问题， 类加载时就完成初始化。

缺点：提前加载，导致性能浪费。 实现延迟加载最好。

         无法避免通过 反射 拿到构造方法，去创建新的实例。

懒汉式（DCL）

双重锁检查加volatile（锁内外各检查一次）

public class LazyMan {
    private LazyMan(){ }
    // 双重锁的判断，在两个线程中是不可见的，一个更改，另一个可能看不到。这样外锁才有意义 
    private volatile static LazyMan lazyMan;
    public static LazyMan getInstance(){
        //外锁是为了避免不必要的等待，已经有锁了 ，就不需要在进去。
        if (lazyMan==null){
            synchronized (LazyMan.class){
                // 为了保证实例 只有一个
                if (lazyMan==null){
                    lazyMan = new LazyMan(); // 不是一个原子性操作
                }
            }
        }
        return lazyMan;
    }
}

优点： 延迟加载， 解决同步问题。

缺点：无法避免反射突破。

volatile ：双重锁的判断，在两个线程中是不可见的，一个更改，另一个可能看不到。这样外锁才有意义...

                强制线程使用该变量时，从主存获取新的值，而不是直接用线程内的值。线程内的值可能是空，但是线程外可能已经被修改过

            volatile ：1保证可见性，要求每次都从主存获取新值，2，不保证原子性 ，2，禁止指令重排

         这里主要是基于指令重排的的影响，假设线程a,b争抢， a先获取锁，创建对象，但是创建对象不是原子的，有几个过程，由于指令重排可能导致，a先创建了指向内存的引用，但是内存内并没有做好初始化。而此时b获取Cpu执行权，外层锁判断对象就不为空，从而获取到一个不完整的实例，造成错误

外锁 ：外锁是为了避免不必要的等待，已经有锁了 ，就不需要在进去。

内锁：为了保证实例 只有一个

反射破解

    public static void main(String[] args) throws Exception {
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        LazyMan instance = declaredConstructor.newInstance();
        LazyMan instance2 = declaredConstructor.newInstance();
        System.out.println(instance);
        System.out.println(instance2);
    }

DCL+ 加密构造

public class LazyMan {
    private static String qinjiang = "asdadasdad";
    private LazyMan(){
        synchronized (LazyMan.class){
            if (qinjiang == "asdadasdad"){
                qinjiang = "";
            }else {
                throw new RuntimeException("不要试图使用反射破坏异常");
            }
        }
    }
    private volatile static LazyMan lazyMan;
    // 双重检测锁模式的 懒汉式单例  DCL懒汉式
    public static LazyMan getInstance(){
        if (lazyMan==null){
            synchronized (LazyMan.class){
                if (lazyMan==null){
                    lazyMan = new LazyMan(); // 不是一个原子性操作
                }
            }
        }
        return lazyMan;
    }
}

由于类加载所以，第一个实例的构造，必然会把字符串置空，此时即使通过反射，也只能拿到空的属性。

内部类

public class Holder {
    private Holder(){

    }
    public static Holder getInstace(){
        return InnerClass.HOLDER;
    }

    public static class InnerClass{
        private static final Holder HOLDER = new Holder();
    }
}

仍然无法避免反射的破解

枚举类

public enum EnumSingle {

    INSTANCE;
    private EnumSingle(){}
    public EnumSingle getInstance(){
        return INSTANCE;
    }
}

 

反射不能突破枚举类

在反射的Constructor 的newInstance方法中，限制了 通过反射创建枚举类。

枚举是真正的 final，客户端不允许创建枚举类的实例，也不能对其进行拓展

也就是枚举类不给外界实例化的机会，只能它自己实例化，而一个枚举类的所有实例就只有枚举前面分号前的那几个，其他地方不允许创建。