单例模式：
单例模式是一种创建型设计模式，其意图是确保一个类只有一个实例，并提供一个全局访问点让其他类能够获取到这个唯一的实例。在 Java 中实现单例模式有多种方式，其中最常见的方式包括懒汉式（Lazy Initialization）、饿汉式（Eager Initialization）、双重检查锁（Double-Checked Locking）等。下面我将详细介绍这些方式，并提供示例代码。
1. 懒汉式（Lazy Initialization）：
懒汉模式（Lazy Initialization）是单例模式的一种常见实现方式之一，在第一次获取单例实例时才进行初始化。它的核心思想是延迟加载，即在需要的时候才创建对象，从而避免了在类加载时就创建对象，节省了资源。
懒汉模式的实现方式：
在 Java 中实现懒汉模式有多种方式，最简单的方式是使用一个私有的静态变量来保存单例实例，在第一次获取实例时进行创建。
示例代码：
public class LazySingleton {
// 声明私有静态变量，但不进行实例化
private static LazySingleton instance;
// 私有化构造方法，防止外部直接实例化
private LazySingleton() {}
// 提供一个公共的静态方法用于获取实例
public static synchronized LazySingleton getInstance() {
if (instance == null) { // 当实例为null时才创建对象
instance = new LazySingleton();
}
return instance;
}
}
懒汉模式的特点和注意事项：
- 延迟加载：在第一次调用
getInstance()方法时才会创建单例对象，避免了在类加载时就进行初始化。 - 线程安全：上述示例中通过加锁实现了线程安全，但是加锁会带来性能损耗。因此，在多线程环境下，懒汉模式需要考虑线程安全问题。
- 存在性能问题：在高并发情况下，由于每次获取单例对象都需要进行同步操作，可能会影响性能。
- 可能引发的问题：
-
- 多线程并发访问时，可能会出现竞态条件（Race Condition）问题，导致多个线程同时通过了
instance == null的检查，从而创建了多个实例。 - 如果在单例类中存在资源释放等需要进行额外处理的逻辑，懒汉模式可能会导致该逻辑出现不一致或者失效的情况。
- 多线程并发访问时，可能会出现竞态条件（Race Condition）问题，导致多个线程同时通过了
懒汉模式的优缺点：
-
优点：
-
- 实现简单，延迟加载，在需要的时候才会创建对象。
- 节省内存，避免了在类加载时就创建对象。
-
缺点：
-
- 线程不安全：需要考虑多线程情况下的线程安全问题，常见的解决方式是加锁，但会影响性能。
- 性能问题：在高并发情况下，加锁会带来性能损耗。
- 可能引发的问题：可能存在竞态条件问题，以及如果单例类中有资源释放等特殊逻辑，需要特别注意。
改进的懒汉模式：
为了解决懒汉模式的线程安全问题和性能问题，可以采用双重检查锁机制（Double-Checked Locking）、静态内部类（Static Inner Class）、枚举（Enum）等方式来改进。
双重检查锁（Double-Checked Locking）：
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;
}
}
静态内部类（Static Inner Class）：
public class StaticInnerClassSingleton {
private StaticInnerClassSingleton() {}
private static class SingletonHolder {
private static final StaticInnerClassSingleton INSTANCE = new StaticInnerClassSingleton();
}
public static StaticInnerClassSingleton getInstance() {
return SingletonHolder.INSTANCE;
}
}
枚举（Enum）：
public enum EnumSingleton {
INSTANCE;
// 可以添加其他方法和属性
public void doSomething() {
System.out.println("Doing something...");
}
}
这些改进方式都解决了懒汉模式的线程安全问题，并且不会造成性能损失，推荐在实际开发中使用。在选择实现方式时，需要根据具体的业务需求、并发情况以及代码风格等因素来选择最适合的单例模式实现方式。
2. 饿汉式（Eager Initialization）：
饿汉模式（Eager Initialization）是单例模式的一种常见实现方式之一。它的特点是在类加载时就进行实例化，因此在程序运行期间始终保持单例对象存在，无论是否被使用。这样做的好处是简单、线程安全，但可能会导致资源浪费，因为无论是否被用到都会被创建。
饿汉模式的实现方式：
在 Java 中实现饿汉模式非常简单，只需要在类的静态成员变量中直接创建单例对象即可。
示例代码：
public class EagerSingleton {
// 声明私有静态变量并直接实例化
private static final EagerSingleton instance = new EagerSingleton();
// 私有化构造方法，防止外部直接实例化
private EagerSingleton() {}
// 提供一个公共的静态方法用于获取实例
public static EagerSingleton getInstance() {
return instance;
}
}
饿汉模式的特点和注意事项：
- 线程安全：由于在类加载时就创建了单例对象，因此保证了在多线程环境下的线程安全性。
- 简单明了：实现简单直接，没有复杂的同步操作。
- 资源浪费：饿汉模式会在程序启动时就创建单例对象，无论后续是否会被使用，可能会造成资源浪费。
- 不适合延迟加载：因为对象在类加载时就被创建了，无法实现延迟加载，如果单例对象的创建和初始化过程比较耗时，会影响程序启动速度。
饿汉模式的优缺点：
-
优点：
-
- 线程安全：无需考虑多线程下的同步问题，类加载时就创建了单例对象。
- 实现简单：代码简洁明了，易于理解。
-
缺点：
-
- 资源浪费：在程序启动时就创建了对象，无论后续是否会被使用，可能会造成资源浪费。
- 不支持延迟加载：由于在类加载时就创建了对象，无法实现按需创建的延迟加载。
饿汉模式的应用场景：
- 单例对象在程序中一直被频繁使用，且创建和初始化的成本较低。
- 程序启动时需要预先加载单例对象，以提高后续访问的效率。
- 不需要延迟加载，一开始就需要创建单例对象。
示例应用：
可以编写一个简单的测试类来验证饿汉模式的单例对象：
public class EagerSingletonTest {
public static void main(String[] args) {
EagerSingleton instance1 = EagerSingleton.getInstance();
EagerSingleton instance2 = EagerSingleton.getInstance();
System.out.println("instance1 hashCode: " + instance1.hashCode());
System.out.println("instance2 hashCode: " + instance2.hashCode());
System.out.println("Is instance1 same as instance2? " + (instance1 == instance2));
}
}
以上是关于饿汉模式的详细介绍。饿汉模式是一种简单、线程安全的单例模式实现方式，适用于单例对象需要在程序启动时就被创建并且一直被频繁使用的场景。但是需要注意的是，由于在类加载时就创建了对象，可能会造成资源的浪费，因此在使用时需谨慎考虑。
3. 双重检查锁（Double-Checked Locking）：
双重检查锁（Double-Checked Locking）是一种在懒汉模式的基础上进行改进的单例模式实现方式。它的核心思想是在获取单例对象时，先检查实例是否已经创建，如果未创建，则进行同步操作创建实例，然后再次检查实例是否已经创建。这样可以减少同步的次数，提高了性能。
双重检查锁的实现方式：
在 Java 中实现双重检查锁需要注意两点：使用 volatile 关键字修饰单例变量，以及进行两次实例检查。
示例代码：
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;
}
}
双重检查锁的特点和注意事项：
- 延迟加载：只有在需要时才会创建单例对象，避免了在类加载时就进行初始化。
- 线程安全：通过双重检查，保证了在多线程环境下的线程安全性。
- 性能优化：减少了同步的次数，在实例已经被创建的情况下不会进入同步块，提高了性能。
- 使用
**volatile**关键字：使用volatile关键字修饰单例变量可以确保多线程环境下的可见性，避免了指令重排序带来的问题。 - 注意指令重排序：在 JDK 1.5 之前的版本，双重检查锁存在指令重排序的问题，因此需要将单例变量声明为
volatile，在 JDK 1.5 及以上版本则不会出现这个问题。
双重检查锁的优缺点：
-
优点：
-
- 线程安全：通过双重检查，保证了在多线程环境下的线程安全性。
- 延迟加载：只有在需要时才会创建单例对象，避免了在类加载时就进行初始化。
- 性能优化：减少了同步的次数，在实例已经被创建的情况下不会进入同步块，提高了性能。
-
缺点：
-
- 实现复杂：相比较懒汉模式，双重检查锁需要进行两次实例检查和同步操作，实现起来较为复杂。
- 可能存在指令重排序问题：在 JDK 1.5 之前的版本，双重检查锁存在指令重排序的问题，需要通过
volatile关键字修饰单例变量来解决。
示例应用：
可以编写一个简单的测试类来验证双重检查锁模式的单例对象：
public class DoubleCheckedSingletonTest {
public static void main(String[] args) {
DoubleCheckedSingleton instance1 = DoubleCheckedSingleton.getInstance();
DoubleCheckedSingleton instance2 = DoubleCheckedSingleton.getInstance();
System.out.println("instance1 hashCode: " + instance1.hashCode());
System.out.println("instance2 hashCode: " + instance2.hashCode());
System.out.println("Is instance1 same as instance2? " + (instance1 == instance2));
}
}
以上就是关于双重检查锁模式的详细介绍。双重检查锁是一种结合了延迟加载和线程安全的单例模式实现方式，在多线程环境下保证了线程安全性，同时又实现了延迟加载，避免了在类加载时就进行初始化的情况。但是需要注意在早期 JDK 版本中存在指令重排序的问题，需要通过 volatile 关键字来解决。在实际应用中，双重检查锁模式是一个性能较好且线程安全的单例模式实现方式。
4. 静态内部类（Static Inner Class）：
静态内部类（Static Inner Class）是一种用于实现单例模式的常见方式之一。它利用了类加载的机制来保证线程安全性和延迟加载，同时保持了单例实例的唯一性。静态内部类的特点是，内部类是静态的，并且在外部类加载的时候不会被加载，只有在第一次使用时才会加载，并且保证了线程安全。
静态内部类的实现方式：
在 Java 中实现静态内部类的单例模式非常简单，只需要在内部类中创建单例对象，并提供一个公共的静态方法来获取这个实例。
示例代码：
public class StaticInnerClassSingleton {
// 私有化构造方法，防止外部直接实例化
private StaticInnerClassSingleton() {}
// 静态内部类
private static class SingletonHolder {
private static final StaticInnerClassSingleton INSTANCE = new StaticInnerClassSingleton();
}
// 提供一个公共的静态方法用于获取实例
public static StaticInnerClassSingleton getInstance() {
return SingletonHolder.INSTANCE;
}
}
静态内部类的特点和注意事项：
- 延迟加载：只有在调用
getInstance()方法时才会加载静态内部类，从而创建单例对象，实现了延迟加载。 - 线程安全：利用了类加载的机制，保证了在多线程环境下的线程安全性。
- 实现简单：代码简洁明了，易于理解和维护。
- 内存占用：静态内部类不会在外部类加载时被初始化，只有在第一次调用
getInstance()方法时才会加载内部类并创建单例对象，因此节省了内存。 - 优雅的单例实现：静态内部类方式实现单例模式被认为是一种优雅的方式，将单例对象的创建逻辑和外部类解耦，使得代码更清晰。
静态内部类的优缺点：
-
优点：
-
- 线程安全：通过静态内部类的特性，保证了在多线程环境下的线程安全性。
- 延迟加载：只有在需要时才会加载内部类，从而创建单例对象。
- 实现简单：代码简洁明了，易于理解和维护。
- 内存占用少：静态内部类不会在外部类加载时被初始化，节省了内存。
-
缺点：
-
- 无法传递参数：静态内部类的方式无法传递参数给单例对象的构造函数，因为内部类的实例化是在调用
getInstance()方法时隐式完成的。
- 无法传递参数：静态内部类的方式无法传递参数给单例对象的构造函数，因为内部类的实例化是在调用
静态内部类的应用场景：
- 需要延迟加载的单例对象，且保证线程安全。
- 不希望在程序启动时就创建单例对象，而是在第一次使用时进行创建。
示例应用：
可以编写一个简单的测试类来验证静态内部类模式的单例对象：
public class StaticInnerClassSingletonTest {
public static void main(String[] args) {
StaticInnerClassSingleton instance1 = StaticInnerClassSingleton.getInstance();
StaticInnerClassSingleton instance2 = StaticInnerClassSingleton.getInstance();
System.out.println("instance1 hashCode: " + instance1.hashCode());
System.out.println("instance2 hashCode: " + instance2.hashCode());
System.out.println("Is instance1 same as instance2? " + (instance1 == instance2));
}
}
以上就是关于静态内部类模式的详细介绍。静态内部类是一种常用的单例模式实现方式，通过利用静态内部类的特性，实现了延迟加载、线程安全和高效的单例对象创建。它的优雅实现和简洁代码使得在实际开发中经常被使用。
5. 枚举（Enum）：
单例模式的枚举（Enum）实现是一种简洁、高效且线程安全的单例模式实现方式。枚举在 Java 中自身就具有线程安全性和序列化的保证，因此使用枚举来实现单例模式可以省去手动编写线程安全和序列化的代码。
单例模式的枚举实现方式：
在 Java 中，使用枚举实现单例模式非常简单，只需要将单例对象定义为枚举的一个实例即可。
示例代码：
public enum EnumSingleton {
INSTANCE;
// 可以添加其他方法和属性
public void doSomething() {
System.out.println("Doing something...");
}
}
单例模式枚举实现的特点和注意事项：
- 线程安全：枚举在 Java 中本身就具有线程安全性，在枚举类型初始化时，只会加载一次，因此保证了线程安全。
- 延迟加载：在枚举中，单例对象的创建是在枚举类型加载时就完成的，因此也实现了延迟加载。
- 防止反射和反序列化攻击：枚举类型在 Java 中有自己的特殊实现方式，可以防止通过反射和反序列化破坏单例模式。
- 简洁明了：使用枚举实现单例模式代码非常简洁，不需要手动编写单例类、构造函数、静态方法等。
- 无法传递参数：由于枚举的特性，无法在枚举实例化时传递参数给构造函数。
单例模式枚举实现的优缺点：
-
优点：
-
- 线程安全：枚举类型本身就具有线程安全性。
- 延迟加载：只有在需要时才会加载枚举类型。
- 防止反射攻击：枚举在 Java 中有自己的实现方式，可以防止通过反射破坏单例。
- 防止反序列化攻击：枚举在 Java 中的序列化和反序列化由 JVM 来保证，可以防止通过反序列化破坏单例。
-
缺点：
-
- 无法传递参数：枚举实例化时无法传递参数给构造函数。
- 不能继承：枚举类型不能被继承，有时可能会限制枚举模式的灵活性。
单例模式枚举实现的应用场景：
- 简单的单例对象，不需要传递参数给构造函数。
- 需要保证线程安全性、防止反射和反序列化攻击的场景。
示例应用：
可以编写一个简单的测试类来验证枚举实现的单例对象：
public class EnumSingletonTest {
public static void main(String[] args) {
EnumSingleton instance1 = EnumSingleton.INSTANCE;
EnumSingleton instance2 = EnumSingleton.INSTANCE;
System.out.println("instance1 hashCode: " + instance1.hashCode());
System.out.println("instance2 hashCode: " + instance2.hashCode());
System.out.println("Is instance1 same as instance2? " + (instance1 == instance2));
// 调用枚举中的方法
instance1.doSomething();
}
}
以上就是关于单例模式的枚举实现的详细介绍。枚举实现的单例模式是一种简洁、高效且线程安全的方式，通过使用枚举类型可以保证单例对象的唯一性、线程安全性和防止反射和反序列化攻击。在实际应用中，如果需要实现一个简单的单例对象且保证线程安全，枚举实现方式是一个很好的选择。
单例模式是一种常见的设计模式，适用于需要保证一个类只有一个实例，并提供全局访问点的情况。它在很多场景中都能发挥作用，以下是一些常见的使用场景以及在业务和框架中的应用示例：
6.单例模式使用场景：
- 资源共享：当多个模块需要共享同一个资源时，例如配置文件、数据库连接池等，可以使用单例模式保证资源的唯一性和共享性。
- 工具类：针对一些工具类，比如日志工具、缓存工具、线程池等，可以使用单例模式确保只有一个实例存在。
- 管理对象的全局访问：比如 Spring 框架中的 Bean 对象，默认情况下都是单例的，保证了在整个应用中只有一个实例。
- 控制某些资源的访问权限：比如 Semaphore（信号量）等资源的控制，在多线程环境下，可以使用单例模式来确保对这些资源的同步访问。
- 日志对象：在应用中需要记录日志时，可以使用单例模式确保日志对象的唯一性。
常见使用示例：
1. 配置管理器
public class ConfigurationManager {
private static ConfigurationManager instance = new ConfigurationManager();
private ConfigurationManager() {
// 私有构造函数，防止外部实例化
}
public static ConfigurationManager getInstance() {
return instance;
}
// 其他方法
public String getConfig(String key) {
// 从配置文件中获取配置信息
return "Value for " + key;
}
}
2. 日志工具类
public class Logger {
private static Logger instance = new Logger();
private Logger() {
// 私有构造函数，防止外部实例化
}
public static Logger getInstance() {
return instance;
}
public void log(String message) {
// 记录日志
System.out.println("Log: " + message);
}
}
3. 数据库连接池
public class ConnectionPool {
private static ConnectionPool instance = new ConnectionPool();
private ConnectionPool() {
// 初始化数据库连接池
}
public static ConnectionPool getInstance() {
return instance;
}
public Connection getConnection() {
// 获取数据库连接
return null;
}
public void releaseConnection(Connection connection) {
// 释放数据库连接
}
}
在框架中的应用示例：
1. Spring 框架中的 Bean 默认为单例
在 Spring 框架中，默认情况下，Bean 是单例的，这意味着在整个应用程序的上下文中只存在一个实例。
@Service
public class MyService {
// Spring 将会创建一个单例的 MyService 实例
}
2. Servlet 中的 ServletContext
在 Servlet 中，ServletContext 也可以看作是一个单例对象，它在整个应用的生命周期中只有一个实例。
public class MyServlet extends HttpServlet {
public void init() {
ServletContext context = getServletContext();
// 使用 ServletContext 对象
}
}
3. 日志框架中的 Logger
常见的日志框架（如 Log4j、SLF4J 等）中，Logger 通常被设计为单例对象，确保应用中只有一个日志对象。
public class MyClass {
private static final Logger LOGGER = LoggerFactory.getLogger(MyClass.class);
public void doSomething() {
LOGGER.info("Doing something...");
}
}
总结：
单例模式在很多场景中都有应用，特别是需要全局访问某个对象、共享资源、控制对象的访问权限等情况下非常有用。在业务逻辑中，可以避免重复创建对象，节省内存和资源；在框架中，可以确保某些对象在整个应用生命周期中只有一个实例，达到统一管理和控制的目的。常见的使用场景包括配置管理器、日志工具类、数据库连接池等。在实际开发中，根据需求和业务场景选择合适的单例模式实现方式，可以提高代码的可维护性、可扩展性和性能优化。
162
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
