【创建者模式-单例设计模式】

概述

这种模式设计到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象方式，可以直接访问，不需要实例化该类的对象。

单例模式的实现

• 饿汉式：即类的初始化阶段就创建单例对象

package com.syn.single;

public class Hungry {
    /*构造方法私有化*/
    private Hungry(){}
    /*类中创建对象*/
    private static Hungry hungry = new Hungry();
    /*提供给外界获取对象的窗口*/
    public static Hungry getInstance(){
        return hungry;
    }
}

• 懒汉式：首次被调用时才创建单例对象

package com.syn.single;

public class Lazy {
    /*私有构造方法*/
    private Lazy(){};
    /*声明单例变量*/
    private static Lazy lazy;
    /*对外提供方法,并加上同步锁*/
    public static synchronized Lazy getInstance(){
        if (lazy == null) {
            lazy = new Lazy();
        }
        return lazy;
    }
}

• 懒汉式-双重检查方式：

package com.syn.single;

public class LazyDouCheck {
    /*私有构造方法*/
    private LazyDouCheck(){};
    /*声明单例变量*/
    private static volatile LazyDouCheck lazyDouCheck;
    /*对外提供方法,并加上同步锁*/
    public static  LazyDouCheck getInstance(){
        /*第一次判断，如果部位null，则直接返回已创建的单例对象*/
        if (lazyDouCheck == null) {
            /*此处锁住类*/
            synchronized (LazyDouCheck.class){
                /*抢到锁之后再次判断是否为null*/
                if (lazyDouCheck == null){
                    lazyDouCheck = new LazyDouCheck();
                }
            }
        }
        return lazyDouCheck;
    }
}

• 饿汉式（恶汉式）- 枚举类：

package com.syn.single;

public enum Evil {
    INSTANCE;
}

破坏单例模式解决方案

1.序列化与反序列化破坏解决

package com.syn.single;

public class Lazy {
    /*私有构造方法*/
    private Lazy(){};
    /*声明单例变量*/
    private static Lazy lazy;
    /*对外提供方法,并加上同步锁*/
    public static synchronized Lazy getInstance(){
        if (lazy == null) {
            lazy = new Lazy();
        }
        return lazy;
    }
    /*反序列化时被调用，如果定义了这个方法，就返回这个方法的值，反之则new新对象*/
    public Object readResolve(){
        return Lazy.lazy;
    }
}

2.反射破坏解决

package com.syn.single;

public class Lazy {
    private static boolean flag = false;
    /*私有构造方法*/
    private Lazy(){
        /*处理多线程问题*/
        synchronized (Lazy.class){
            /*根据flag判断对象是否已经创建*/
            if (false){
                throw new RuntimeException("不能创建多个对象");
            }
            flag = true;
        }
    };
    /*声明单例变量*/
    private static Lazy lazy;
    /*对外提供方法,并加上同步锁*/
    public static synchronized Lazy getInstance(){
        if (lazy == null) {
            lazy = new Lazy();
        }
        return lazy;
    }
}