单例模式的学习与使用

1、单例模式的学习

  当我们需要确保一个类只有一个实例并且全局可访问时，可以使用单例模式。单例模式是一种创建型设计模式，它保证一个类只有一个实例，并提供一个全局访问点以便于其他对象可以使用该实例。
  单例模式通常具有以下几个要素：

1. 私有构造函数：单例类的构造函数被标记为私有，以防止其他类直接实例化它。
2. 静态实例变量：单例类内部维护一个静态变量来持有该类的唯一实例。
3. 全局访问方法：单例类提供一个静态方法，允许其他对象通过该方法访问单例实例。

  单例模式有几种常见的实现方式：

1. 饿汉式：在类加载时即创建实例，立即加载。天然线程安全，但可能造成资源浪费。
2. 懒汉式：在首次访问时创建实例，延迟加载。线程安全需要考虑同步控制。
3. 双重检查锁式：使用双重检查锁机制，在保证线程安全的同时实现延迟加载。
4. 静态内部类式：利用静态内部类的特性，在类加载时创建实例，实现延迟加载和线程安全。
5. 枚举式：使用枚举类型创建单例，天然线程安全且防止反射和序列化攻击。

选择哪种实现方式取决于具体的需求和场景。在多线程环境下，需要考虑线程安全性和性能。此外，要注意避免单例模式的滥用，因为它可能导致代码的耦合性和可测试性降低。

2、单例模式的使用

  设计一个日志管理器类，要求该类只能有一个实例，并且可以通过全局访问点获取该实例。该日志管理器可以记录系统中的日志信息。
饿汉式

public class LogManagerA {

    private LogManagerA() {
    }

    private static final LogManagerA logManagerA = new LogManagerA();

    public static LogManagerA getInstance() {
        return logManagerA;
    }

    public void recordLog(String log) {
        System.out.println("开始记录日志信息:" + log);
    }

}

懒汉式

public class LogManagerB {

    private LogManagerB() {
    }

    private static LogManagerB logManagerB = null;

    public static synchronized LogManagerB getInstance() {
        if (Objects.isNull(logManagerB)) {
            logManagerB = new LogManagerB();
        }
        return logManagerB;
    }

    public void recordLog(String log) {
        System.out.println("开始记录日志信息:" + log);
    }
}

双重检查锁式

public class LogManagerC {

    private LogManagerC() {
    }

    private static volatile LogManagerC logManagerC = null;

    public static LogManagerC getInstance() {
        if (Objects.isNull(logManagerC)) {
            synchronized (LogManagerC.class) {
                if (Objects.isNull(logManagerC)) {
                    logManagerC = new LogManagerC();
                }
            }
        }
        return logManagerC;
    }

    public void recordLog(String log) {
        System.out.println("开始记录日志信息:" + log);
    }
}

静态内部类式

public class LogManagerD {

    private LogManagerD() {
    }

    public static class LogManagerDInstance {
        private static final LogManagerD logManagerD = new LogManagerD();

        public static LogManagerD getInstance() {
            return logManagerD;
        }
    }

    public void recordLog(String log) {
        System.out.println("开始记录日志信息:" + log);
    }
}

枚举式

public enum LogManagerE {
    INSTANCE;

    public void recordLog(String log) {
        System.out.println("开始记录日志信息:" + log);
    }
}

日志记录客户端

public class LogClient {

    public static void main(String[] args) {
        LogManagerA logManagerA = LogManagerA.getInstance();
        logManagerA.recordLog("成功创建logManagerA实例");

        LogManagerB logManagerB = LogManagerB.getInstance();
        logManagerB.recordLog("成功创建logManagerB实例");

        LogManagerC logManagerC = LogManagerC.getInstance();
        logManagerC.recordLog("成功创建logManagerC实例");

        LogManagerD logManagerD = LogManagerD.LogManagerDInstance.getInstance();
        logManagerD.recordLog("成功创建logManagerD实例");

        LogManagerE logManagerE = LogManagerE.INSTANCE;
        logManagerE.recordLog("成功创建logManagerE实例");
    }
}

开始记录日志信息:成功创建logManagerA实例
开始记录日志信息:成功创建logManagerB实例
开始记录日志信息:成功创建logManagerC实例
开始记录日志信息:成功创建logManagerD实例
开始记录日志信息:成功创建logManagerE实例