设计模式-单例模式

设计模式是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。分为创建型模式，结构性模式，行为模式，创建型模式就是处理对象创建的设计模式，创建型模式有两个主导思想构成。一是将系统使用的具体类型封装起来，二是隐藏这些具体类的实例创建和结合的方式。结构型模式通过对多个类和对象进行组合得到复杂结构的类，一般使用继承或者成员变量引用形式来实现，行为型模式：行为模式不仅表达了对象和类，还表达了他们之间的交互，涉及到了对象和算法的分配．
　单例模式就属于创建型模式，对某个类只能存在一个对象实例,并且该类只提供一个取得对象实例的方法．特点就是构造器私有化，类内部创建对象，向外暴露一个公共的静态方法．

饿汉式　在类装载的时候就完成了实例化，但是如果从始至终从未使用过这个实例,则会造成内存浪费．

public class Hungry {

    private Hungry(){

    }

    private final static Hungry HUNGRY = new Hungry();

    public static Hungry getInstance(){
        return HUNGRY;
    }
}

懒汉式

class Singleton{
	private static Singleton singleton;
	private Singleton(){}
	public static Singleton getInstance(){
	if(singleton == null){
	synchronized(){
	singleton = new Singleton();
}
}
return singleton;
	}
}

双重检测

public class LazyImprove {

    private static boolean xxx =false;

    private LazyImprove(){
        synchronized (LazyImprove.class){
            if(xxx == false){
                xxx =true;
            }else {
                throw new RuntimeException("不要试图使用反射破坏");
            }


        }

    }

    private volatile static LazyImprove lazy;

    /**
     * 双重检测　DCL懒汉式
     * @return
     */
    public  static LazyImprove getInstance(){
        if (lazy == null){
            synchronized (LazyImprove.class){
                if (lazy == null){
                    //不是原子性操作
                    lazy = new LazyImprove();
                    /**
                     * 1.分配内存空间
                     * 2.执行构造方法,初始化对象
                     * 3.把这个对象指向这个空间
                     */
                }
            }
        }

        return lazy;
    }

    /**
     * 多线程并发
     */
    public static void main(String[] args) throws Exception {

        Field xxx = Lazy.class.getDeclaredField("xxx");
        xxx.setAccessible(true);

        Constructor<LazyImprove> declaredConstructor = LazyImprove.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        LazyImprove instance = declaredConstructor.newInstance();
        xxx.set(instance,false);
        LazyImprove instance1 = declaredConstructor.newInstance();
        System.out.println(instance.hashCode());
        System.out.println(instance1.hashCode());
    }

}

静态内部类实现

public class Holder {

    private Holder(){

    }

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

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

枚举类

/**
 * enum　jdk1.5之后　本身也是一个Class类
 * @author maomao
 */
public enum  EnumSingle {
    INSTANCE;

    public EnumSingle getInstance(){
        return INSTANCE;
    }
}
class Test{
    public static void main(String[] args) throws Exception {
        EnumSingle instance1 = EnumSingle.INSTANCE;
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);
        declaredConstructor.setAccessible(true);
        EnumSingle enumSingle = declaredConstructor.newInstance();
        //
        System.out.println(instance1);
        System.out.println(enumSingle);
    }
}