三种单例模式

三种单例模式

饿汉式

package com.young.demo.single;
//饿汉式单例 （可能会浪费空间）不管用不用，上来就直接实例化

public class Hungry {
    private  Hungry(){

    }
    private static final Hungry HUNGRY = new Hungry();

    public Hungry getinstance(){
        return HUNGRY;
    }

DCL懒汉式 双重检测锁模式（包括原子性操作，）

下面代码给了一个标志位，为了防止反射通过构造器实例化类，但是也并不能完美解决（反射可以通过字段拿到）

package com.young.demo.single;

import java.lang.reflect.Constructor;

//懒汉式单例
//单线程下单例可以的，但是在多线程并发下会存在问题
public class Lazyman {
    private static boolean young = false;
    private Lazyman(){
    if (young){
        young = true;
    }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(); //不是一个原子性操作
                    /**
                     * 对象实例化步骤
                     * 1、分配内存空间
                     * 2、执行构造方法，初始化对象
                     * 3、把这个对象指向这个空间
                     * 未加Volatile前
                     * 线程A执行，无论指令怎么重排都没有问题
                     * 但是在来一个线程B进行实例化时，在进行检测时，会以为			这个对象不为null
                     * 直接返回，但是这个对象的构造没有完成
                     */
                }
            }
        }
        return lazyman;
    }
    //反射可以解决单例模式
    public static void main(String[] args) throws Exception {
        Lazyman instance = Lazyman.getInstance();
        Constructor<Lazyman> constructor = Lazyman.class.getConstructor(null);
        constructor.setAccessible(true);
        Lazyman instance1 = constructor.newInstance();
		system.out.println(instance);
		system.out.println(instance1);
		//我们会发现这两个的地址不一样，单例模式也就被破解了
    }
 }

静态内部类

package com.young.demo.single;
//静态内部类
public class Holder {
    private Holder(){

    }
    public static Holder getInstance(){
        return Inner.HOLDER;
    }
    public static class Inner {
        private static final Holder HOLDER = new Holder();
    }
}