设计模式-单例模式

1. 懒汉模式

方式一：

/**
 * <p>
 * 经典懒汉方式
 * </p>
 *
 */
public class Singleton {
    private static Singleton singleton;

    private Singleton() {
    }

    public static Singleton getInstance() {
        if (ObjectUtil.isNull(singleton)) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

方式二：

/**
 * <p>
 * 懒汉 线程安全
 * </p>
 *
 */
public class Singleton3 {
    private static Singleton3 singleton;

    private Singleton3() {
    }

    public static synchronized Singleton3 getInstance() {
        if (ObjectUtil.isNull(singleton)) {
            singleton = new Singleton3();
        }
        return singleton;
    }
}

2.饿汉模式

方式一：

/**
 * <p>
 * 经典饿汉方式
 * </p>
 *
 */
public class Singleton2 {
    private static Singleton2 singleton = new Singleton2();

    private Singleton2() {
    }

    public static Singleton2 getInstance() {
        return singleton;
    }
}

方式二：

/**
 * <p>
 *饿汉-静态内部类
 * </p>
 *
 */
public class Singleton5 implements Serializable {
    private static Singleton5 singleton5 = null;


    private Singleton5() {
    }


    private static class SingletonHandler {
        private static Singleton5 singleton5 = new Singleton5();

    }

    public static Singleton5 getInstance() {
        return SingletonHandler.singleton5;
    }

    Object readResolve() {
        return singleton5;
    }
}

3.双检锁

/**
 * <p>
 * 双检锁
 * </p>
 *
 */
public class Singleton4 {
    private volatile static Singleton4 singleton;

    private Singleton4() {
    }

    public static Singleton4 getInstance() {
        if (ObjectUtil.isNull(singleton)) {
            synchronized (Singleton4.class) {
                if (ObjectUtil.isNull(singleton)) {
                    singleton = new Singleton4();
                }
            }
        }
        return singleton;
    }
}

4.枚举

/**
 * <p>
 * 懒汉
 * 枚举单例 为最安全 无法通过反射、序列化等破解
 * 枚举底层为类实现，不允许反射
 * </p>
 *
 */
public enum SingletonEnum {
    /** 实例 */
    INSTANCE;

    /**
     *
     * @return
     */
    public SingletonEnum getInstance() {
        return INSTANCE;
    }
}

5.单例工厂

/**
 * <p>
 *单例工厂
 * </p>
 *
 */
public class SingletonFactory {
    /**
     * 获取单例对象
     */
    public static <T> T getInstance(Class<? extends T> classname) {
        try {
            Constructor constructor = classname.getDeclaredConstructor();
            constructor.setAccessible(true);
            return  (T) constructor.newInstance();
        } catch (InstantiationException | InvocationTargetException |
                IllegalAccessException |
                NoSuchMethodException e) {
            e.printStackTrace();
        }
        return null;
    }

    @SuppressWarnings("rawtypes")
    private static Map<Class, Object> instaces = new ConcurrentHashMap<Class, Object>();
    @SuppressWarnings("rawtypes")
    private static Map<Class, WeakReference<Object>> weakReferenceInstaces = new ConcurrentHashMap<Class, WeakReference<Object>>();

    /**
     * 创建可不被回收的单例模式,当没有对象引用，单例对象将被gc掉
     *
     */
    @SuppressWarnings("unchecked")
    public static <T> T getService(Class<? extends T> className) {
        Object instace = instaces.get(className);
        if (instace == null) {
            synchronized (SingletonFactory.class) {
                instace = instaces.get(className);
                if (instace == null) {
                    instace = getInstance(className);
                    instaces.put(className, instace);
                }
            }
        }
        return (T) instace;
    }

    /**
     * 创建可回收的单例模式,当没有对象引用，单例对象将被gc掉
     *
     */
    @SuppressWarnings("unchecked")
    public static <E> E getWeakInstace(Class<E> className) {
        WeakReference<Object> reference = weakReferenceInstaces.get(className);
        Object instace = reference == null?null:reference.get();
        if (instace == null) {
            synchronized (SingletonFactory.class) {
                reference = weakReferenceInstaces.get(className);
                instace = reference == null ? null : reference.get();
                if(instace == null){
                    instace = getInstance(className);
                    weakReferenceInstaces.put(className,new WeakReference<Object>(instace));
                }
            }
        }
        return (E)instace;
    }
    public static void main(String[] args) {
//      Object o=  getInstance(College.class);
//      System.out.println(o);

    }
}