Java 设计模式 - 单例模式 - 保证类只有一个实例

单例模式 - 保证类只有一个实例

- 为什么使用单例模式？
- 单例模式的实现方式
- - [1. 饿汉式（Eager Initialization）](#1. 饿汉式（Eager Initialization）)
  - [2. 懒汉式（Lazy Initialization）](#2. 懒汉式（Lazy Initialization）)
  - [3. 双重检查锁（Double-Checked Locking）](#3. 双重检查锁（Double-Checked Locking）)
  - [4. 静态内部类（Static Inner Class）](#4. 静态内部类（Static Inner Class）)
- 线程安全考虑
- 总结

单例模式是一种创建型设计模式，它确保一个类只有一个实例，并提供一个全局访问点来获取该实例。在某些情况下，我们需要确保一个类的实例在整个应用程序中是唯一的，这时候单例模式就非常有用。在本篇博客中，我们将详细探讨单例模式的概念、实现方式以及如何在Java中创建一个线程安全的单例。

为什么使用单例模式？

单例模式的主要目的是避免在应用程序中创建多个实例，从而节省资源并确保类的实例唯一性。它可以用于以下场景：

全局配置类：某些类的实例在整个应用程序中保持一致，如数据库连接池、日志配置等。
资源共享：当多个对象需要共享一份资源时，通过单例模式可以确保资源只有一个实例，避免资源浪费和冲突。
频繁使用的对象：某些对象频繁被使用，重复创建实例会带来不必要的开销，使用单例模式可以避免这种情况。

单例模式的实现方式

在Java中，单例模式的实现有多种方式，我们将介绍以下几种常见的实现方式：

1. 饿汉式（Eager Initialization）

这种方式在类加载时就创建了唯一的实例，由于是在类加载时创建的，因此线程安全。

java 复制代码

public class EagerSingleton {
    private static final EagerSingleton instance = new EagerSingleton();

    private EagerSingleton() {
        // 私有构造方法，防止外部实例化
    }

    public static EagerSingleton getInstance() {
        return instance;
    }
}

2. 懒汉式（Lazy Initialization）

这种方式在第一次获取实例时才会创建，避免了类加载时的资源浪费。需要注意的是，懒汉式在多线程环境下需要考虑线程安全问题。

java 复制代码

public class LazySingleton {
    private static LazySingleton instance;

    private LazySingleton() {
        // 私有构造方法，防止外部实例化
    }

    public static synchronized LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}

3. 双重检查锁（Double-Checked Locking）

这种方式结合了懒汉式和饿汉式的优点，实现了延迟加载和线程安全。

java 复制代码

public class DoubleCheckedSingleton {
    private static volatile DoubleCheckedSingleton instance;

    private DoubleCheckedSingleton() {
        // 私有构造方法，防止外部实例化
    }

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

4. 静态内部类（Static Inner Class）

这种方式利用了Java类加载的特性，在静态内部类被加载时才会创建实例，从而实现延迟加载和线程安全。

java 复制代码

public class StaticInnerClassSingleton {
    private StaticInnerClassSingleton() {
        // 私有构造方法，防止外部实例化
    }

    private static class SingletonHolder {
        private static final StaticInnerClassSingleton instance = new StaticInnerClassSingleton();
    }

    public static StaticInnerClassSingleton getInstance() {
        return SingletonHolder.instance;
    }
}

线程安全考虑

在多线程环境下，单例模式的实现需要考虑线程安全性。上述几种方式中，懒汉式、双重检查锁和静态内部类都可以实现线程安全。饿汉式在类加载时就创建了实例，因此也是线程安全的。

总结

单例模式确保一个类只有一个实例，并提供全局访问点来获取该实例。通过适当的实现方式，可以实现延迟加载和线程安全。在应用程序中使用单例模式可以节省资源，避免重复创建实例，并确保实例的唯一性。

以上是关于单例模式的详细介绍及常见实现方式的示例代码。希望通过本篇博客，你对单例模式有了更深入的理解。在实际应用中，根据具体场景选择适合的单例模式实现方式是非常重要的。通过合理使用单例模式，可以优化应用程序的性能和资源利用。