Java日志工具类的单例模式实现与优化

背景：为何需要自定义日志工具

在软件开发中，打印日志是调试和定位问题的关键手段。虽然 System.out.println() 在初学者阶段使用便捷，但在正式项目中存在明显缺陷：

• 不可控性：无法按级别过滤，上线后若仍输出所有信息会严重拖慢运行效率。
• 持久化缺失：控制台输出无法保存至本地文件，进程结束后日志即丢失。
• 缺乏标识：没有Tag区分来源类，难以快速追踪错误上下文。

因此，通常任务是为团队开发一个具备日志级别控制能力的工具类。初期版本可能仅关注功能实现，但随着使用场景复杂化，内存占用和线程安全等问题随之浮现，这便引入了设计模式中的单例模式。

第一步：基础功能实现

首先，我们需要定义日志级别（DEBUG, INFO, ERROR, NOTHING），并提供对应的方法。初始实现允许直接实例化调用：

public class LogUtil {
    public final int DEBUG = 0;
    public final int INFO = 1;
    public final int ERROR = 2;
    public final int NOTHING = 3;

    public int level = DEBUG;

    public void debug(String msg) {
        if (DEBUG >= level) {
            System.out.println(msg);
        }
    }

    public void info(String msg) {
        if (INFO >= level) {
            System.out.println(msg);
        }
    }

    public void error(String msg) {
        if (ERROR >= level) {
            System.out.println(msg);
        }
    }
}

使用时通过 new LogUtil().debug("Hello World!") 进行调用。这种方式的弊端在于每次调用都会创建新对象，导致不必要的内存开销。

第二步：引入懒汉式单例模式

为了解决实例重复创建的问题，可将构造函数私有化，并通过静态方法获取唯一实例。这是最常见的“懒汉式”写法：

public class LogUtil {
    private static LogUtil logUtilInstance;

    // 日志级别常量...
    public final int DEBUG = 0;
    public final int INFO = 1;
    public final int ERROR = 2;
    public final int NOTHING = 3;
    public int level = DEBUG;

    // 私有构造函数
    private LogUtil() {
    }

    // 获取实例
    public static LogUtil getInstance() {
        if (logUtilInstance == null) {
            logUtilInstance = new LogUtil();
        }
        return logUtilInstance;
    }

    // 日志方法同上...
}

此时调用方式变为 LogUtil.getInstance().debug("Hello World")。然而，这段代码在多线程环境下存在严重隐患。

第三步：解决线程安全问题

当两个线程同时进入 getInstance 方法时，若第一个线程执行完 if (logUtilInstance == null) 判定但尚未执行实例化代码，第二个线程可能同样发现实例为空并进入判断，从而创建两个不同的实例对象，违背单例原则。

第1步：方法级同步锁

最简单的修正是在方法声明前加上 synchronized 关键字：

public synchronized static LogUtil getInstance() {
    if (logUtilInstance == null) {
        logUtilInstance = new LogUtil();
    }
    return logUtilInstance;
}

这确保了同一时刻只有一个线程能执行该方法，但缺点是每次调用都会受到锁的影响，导致性能下降，因为后续获取实例的操作其实无需加锁。

第2步：双重检查锁（DCL）优化

为了兼顾线程安全与执行效率，可以将锁的范围缩小到实例化的关键时刻，这就是“双重检查锁”机制：

public static LogUtil getInstance() {
    if (logUtilInstance == null) {                  // 第一次检查
        synchronized (LogUtil.class) {
            if (logUtilInstance == null) {          // 第二次检查
                logUtilInstance = new LogUtil();
            }
        }
    }
    return logUtilInstance;
}

原理解析：

1. 第一次检查：若实例已创建，直接返回，避免加锁开销，提升性能。
2. 加锁与第二次检查：若实例未创建，进入同步块。再次检查是为了防止在等待锁的过程中，其他线程已经完成了实例化。只有确认仍未初始化，才真正创建实例。

第四步：替代方案——饿汉式单例

在Java中，还有一种更简洁且绝对线程安全的实现方式——饿汉式。它在类加载时就创建实例，避免了复杂的同步逻辑。

public class LogUtil {
    // 类加载时即创建实例
    private static final LogUtil logUtilInstance = new LogUtil();

    // 日志级别常量...
    public final int DEBUG = 0;
    public final int INFO = 1;
    public final int ERROR = 2;
    public final int NOTHING = 3;
    public int level = DEBUG;

    private LogUtil() {
    }

    public static LogUtil getInstance() {
        return logUtilInstance;
    }

    // 日志方法同上...
}

对比总结：

• 懒汉式：延迟加载，节省内存（如果从未使用则不创建），但需处理并发问题（如DCL或synchronized）。
• 饿汉式：空间换时间，类加载即创建，天然线程安全，代码简洁。对于大多数工具类而言，推荐使用饿汉式。

以上就是Java单例模式在日志工具类中的应用详解，更多关于Java设计模式的资料请关注本站其它相关文章！