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

「爱情、让人受尽委屈。」 2024-03-22 22:01 47阅读 0赞

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

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

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

### 为什么使用单例模式？ ###

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

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

### 单例模式的实现方式 ###

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

#### 1. 饿汉式（Eager Initialization） ####

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

public class EagerSingleton {
        
        private static final EagerSingleton instance = new EagerSingleton();
    
        private EagerSingleton() {
        
            // 私有构造方法，防止外部实例化
        }
    
        public static EagerSingleton getInstance() {
        
            return instance;
        }
    }

#### 2. 懒汉式（Lazy Initialization） ####

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

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） ####

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

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类加载的特性，在静态内部类被加载时才会创建实例，从而实现延迟加载和线程安全。

public class StaticInnerClassSingleton {
        
        private StaticInnerClassSingleton() {
        
            // 私有构造方法，防止外部实例化
        }
    
        private static class SingletonHolder {
        
            private static final StaticInnerClassSingleton instance = new StaticInnerClassSingleton();
        }
    
        public static StaticInnerClassSingleton getInstance() {
        
            return SingletonHolder.instance;
        }
    }

### 线程安全考虑 ###

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

### 总结 ###

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

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