设计模式--单例模式Demo

Singleton Pattern

1、什么是单例模式?(Singleton Pattern)

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

2、主要解决什么问题?

一个全局使用的类频繁地创建与销毁。

3、何时使用？

当您想控制实例数目，节省系统资源的时候。

4、如何解决？

判断系统是否已经有这个单例，如果有则返回，如果没有则创建。

5、关键代码?

构造函数是私有的。

6、实现

6.1、懒汉式-线程不安全

/**
 * ClassName:LHanUnSafe
 * Describe: 懒汉式-线程不安全
 *          是否 Lazy 初始化：是
 *          是否多线程安全：否
 * Author:DGJ
 * Data:2021/3/2 10:26
 */
public class LHanUnSafe {
    private static LHanUnSafe lHanUnSafe;
    private LHanUnSafe(){}

    public static LHanUnSafe getInstance(){
        if(lHanUnSafe == null){
            return new LHanUnSafe();
        }
        return lHanUnSafe;
    }
}

6.2、懒汉式-线程安全

/**
 * ClassName:LHanSafe
 * Describe: 懒汉式-线程安全
 *          是否 Lazy 初始化：是
 *          是否多线程安全：是
 * Author:DGJ
 * Data:2021/3/2 10:29
 */
public class LHanSafe {
    private static LHanSafe lHanSafe;
    private LHanSafe(){}

    public static synchronized LHanSafe getInstance(){
        if(lHanSafe == null){
            return new LHanSafe();
        }

        return lHanSafe;
    }
}

6.3、饿汉式

/**
 * ClassName:EHan
 * Describe:饿汉式
 *          是否 Lazy 初始化：否
 *           是否多线程安全：是
 * Author:DGJ
 * Data:2021/3/2 10:31
 */
public class EHan {

    private static EHan eHan = new EHan();

    private EHan() {
    }

    public static EHan getInstance() {
        return eHan;
    }
}

6.4、双重校验锁

/**
 * ClassName:DoubleCheckingLockSingletonPattern
 * Describe: double-checked locking(双重校验锁)
 * 是否 Lazy 初始化：是
 * 是否多线程安全：是
 * Author:DGJ
 * Data:2021/3/2 10:34
 */
public class DoubleCheckedLockingSingletonPattern {
    private volatile static DoubleCheckedLockingSingletonPattern doubleCheckedLockingSingletonPattern;

    private DoubleCheckedLockingSingletonPattern() {
    }

    public static DoubleCheckedLockingSingletonPattern getInstance() {
        if (doubleCheckedLockingSingletonPattern == null) {
            synchronized (DoubleCheckedLockingSingletonPattern.class) {
                if (doubleCheckedLockingSingletonPattern == null) {
                    doubleCheckedLockingSingletonPattern = new DoubleCheckedLockingSingletonPattern();
                }
            }
        }
        return doubleCheckedLockingSingletonPattern;
    }

}

6.5、静态内部类

/**
 * ClassName:StaticSingletonPattern
 * Describe:静态内部类
 *          是否 Lazy 初始化：是
 *           是否多线程安全：是
 * Author:DGJ
 * Data:2021/3/2 10:38
 */
public class StaticSingletonPattern {
    private static class StaticSingletonPatternHolder {
        private static final StaticSingletonPattern STATIC_SINGLETON_PATTERN = new StaticSingletonPattern();
    }

    private StaticSingletonPattern() {
    }

    public static final StaticSingletonPattern getInstance() {
        return StaticSingletonPatternHolder.STATIC_SINGLETON_PATTERN;
    }
}

6.6、枚举

/**
 * ClassName:EnmuSingletonPattern
 * Describe: 枚举
 *          是否 Lazy 初始化：否
 *           是否多线程安全：是
 * Author:DGJ
 * Data:2021/3/2 10:44
 */
public enum  EnmuSingletonPattern {
    INSTANCE;
    public void getInstance(){
    }
}