单例模式面试题及答案

爱被打了一巴掌 2024-02-05 17:06 18阅读 0赞

### 1、什么是单例模式？它用于解决什么问题？ ###

单例模式是一种设计模式，它确保一个类只有一个实例，并提供一个全局访问点来获取这个实例。单例模式属于创建型模式，它提供了一种控制对象创建过程的方式。

#### 作用: ####

单例模式用于解决以下问题：

1.  **全局访问点**：单例模式提供一个全局访问点供外部访问唯一的实例，这对于协调系统整体的操作很有帮助。
2.  **控制资源的使用**：通过确保只有一个实例，单例可以控制对共享资源的访问，例如，连接池或配置管理器通常设计为单例。
3.  **节省系统资源**：创建对象通常需要占用系统资源的时间和空间。如果一个对象的实例只需要一个，那么重复创建相同的对象就是资源的浪费。单例模式就可以避免这种浪费。
4.  **数据共享**：单例实例通常用于在不同的系统组件间共享数据，整个应用程序的不同部分可以方便地访问单例类的数据。
5.  **控制实例的数量**：单例模式严格控制一个类的实例数量，确保系统中绝对不会有多个实例。

#### 实现单例模式的关键点: ####

1.  **私有构造函数**：为了防止外部通过`new`创建多个实例，单例类的构造函数应该是私有的。
2.  **提供一个获取实例的方法**：通常是一个公有的静态方法，如`getInstance()`，用于返回单例类的唯一实例。
3.  **确保线程安全**：在多线程环境下，需要确保类的实例化过程是线程安全的。
4.  **延迟初始化**：单例实例不是在类加载时就立即创建，而是在首次使用时创建，这称为延迟初始化。
5.  **防止实例被克隆**：如果单例类实现了`Cloneable`接口，需要重写`clone()`方法，防止通过克隆创建新的实例。
6.  **序列化与反序列化保护**：如果单例类实现了`Serializable`接口，需要考虑反序列化时不会创建新的实例。

#### 实现方式: ####

1.  **饿汉式**：在类加载时就创建类的实例，简单但不提供延迟初始化。
2.  **懒汉式**：在第一次调用`getInstance()`方法时创建实例，可提供延迟初始化，但需要处理多线程安全问题。
3.  **双重检查锁定（Double-Checked Locking）**：在懒汉式的基础上增加了锁，用于在多线程环境中保护单例的唯一性。
4.  **静态内部类**：利用类加载机制保证初始化实例时只有一个线程，同时实现延迟加载。
5.  **枚举**：使用枚举方式实现单例模式是最简洁的方法，它由JVM提供保障，防止通过反射破坏单例。

#### 深入理解: ####

单例模式不仅要求控制对象的创建，还要提供适当的机制以支持对唯一实例的全局访问。在深入使用时，单例模式还需要考虑资源管理、异常处理、系统的可测试性，以及如何清晰地在代码中标识这种模式的使用。

使用单例时也要注意它的缺点，例如，单例可能导致代码间存在隐藏的依赖关系，它们不是通过接口传递的依赖项，而是通过直接调用单例方法获取的，这可能会影响到系统的灵活性和可测试性。此外，使用单例存储全局状态可能会导致代码难以追踪和维护。因此，应当谨慎考虑何时使用单例模式。

### 2、懒汉式和饿汉式的区别 ###

懒汉式和饿汉式是实现单例模式的两种常见方式，它们在初始化单例实例的时机和方式上有所不同。

#### 饿汉式单例： ####

**初始化时机**：类加载时就完成了实例的初始化。也就是说，一旦类被装载到内存中，就会立即实例化一个对象。

**实现方法**：将单例的实例声明为私有静态成员变量，并同时进行实例化。获取实例的方法直接返回这个实例。

**优点**：

*  线程安全：由于实例是在类加载时创建的，所以在任何线程访问实例之前，实例已经完成了初始化，保证了线程安全。
 *  实现简单：不需要额外的同步代码，写起来比较直接。

**缺点**：

*  不支持延迟加载：如果单例类的构造方法中包含了较为耗时的操作，那么这些操作将在类加载时就进行，可能会导致启动速度慢。
 *  可能导致资源浪费：如果程序从始至终都没用到这个实例，那么实例的内存一直无法被释放，造成内存的浪费。

#### 懒汉式单例： ####

**初始化时机**：类的实例被第一次使用时才进行初始化，也就是调用`getInstance()`方法时才创建实例，实现了懒加载（Lazy Loading）。

**实现方法**：单例的实例被声明为私有静态成员变量，但不进行实例化。实例化发生在公有的静态`getInstance()`方法中，该方法首次被调用时创建实例。

**优点**：

*  延迟加载：实例在需要的时候才创建，可以减少资源的浪费。
 *  节省资源：如果实例没有被使用，就不会去初始化实例，节省了系统资源。

**缺点**：

*  线程不安全：如果多个线程同时访问`getInstance()`方法时，可能会同时创建多个实例。因此，需要通过同步机制来解决这个问题，例如通过`synchronized`关键字。
 *  性能问题：如果同步方法没有被正确实现（如直接将`getInstance()`方法声明为`synchronized`），会导致每次访问时都需要进行线程同步，这会大大降低性能。

#### 对比总结： ####

*  **初始化时机**：饿汉式在类加载时初始化，懒汉式在第一次使用时初始化。
 *  **资源和性能**：饿汉式可能造成资源浪费，懒汉式可能由于同步导致性能下降。
 *  **线程安全**：饿汉式天生线程安全，懒汉式需要额外的同步机制来保证线程安全。

在选择使用哪种实现方式时，需要考虑实际应用的需求：如果对启动速度不是很敏感，或者说对实例的使用几乎是必然的，那么饿汉式是一个不错的选择。而如果需要懒加载，或者初始化过程中涉及到大量资源的配置，那么懒汉式可能更适合。不过，在多线程环境下实现懒汉式单例，需要特别注意线程安全和性能的问题。

### 3、如何确保单例模式在多线程环境中是线程安全的？ ###

在多线程环境中确保单例模式的线程安全，关键是要控制实例的初始化过程，只允许一个线程创建单例对象，同时确保所有线程访问的是同一个实例。以下是几种常见的实现线程安全的单例模式方法：

#### 1. 同步方法（懒汉式实现） ####

在`getInstance()`方法上添加`synchronized`关键字，可以防止多个线程同时执行这个方法。每个线程在进入这个方法之前，都必须等待其他线程离开该方法，这保证了只有一个线程可以创建实例。

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

**缺点**：每次调用`getInstance()`方法时都进行同步，这可能导致不必要的同步开销，降低了性能。

#### 2. 双重检查锁定（Double-Checked Locking，DCL） ####

双重检查锁定模式在`getInstance()`加锁的基础上增加了一个如果实例已创建就不需要再加锁的逻辑。这减少了加锁的次数，提高了性能，同时也保证了线程安全。

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

在这段代码中，`volatile`关键字是必须的，它确保了`instance`变量的写操作之前的所有操作都不会被编译器优化掉，并且其他线程能够看到它的值。

#### 3. 静态内部类（懒汉式的一种） ####

静态内部类方式是懒汉式单例的一种改进方式，它利用了类加载机制保证了单例只会被创建一次，并且只有在真正使用的时候才创建。

public class Singleton {
        
        private static class SingletonHolder {
        
            private static final Singleton INSTANCE = new Singleton();
        }
    
        private Singleton() {
        }
    
        public static Singleton getInstance() {
        
            return SingletonHolder.INSTANCE;
        }
    }

这种方式既实现了懒加载，又由JVM提供了对线程安全的支持。

#### 4. 枚举（Effective Java 推荐） ####

Joshua Bloch在他的著作《Effective Java》中提出了使用枚举实现单例的方法，这被认为是最简洁，自动支持序列化机制，绝对防止多次实例化即是序列化也是线程安全的。

public enum Singleton {
        
        INSTANCE;
    
        public void doSomething() {
        
            // Perform operation here
        }
    }

枚举单例的写法简单，而且枚举实例的创建是线程安全的。但是其缺点是不够灵活，比如不能延迟初始化。

#### 综合对比： ####

*  **同步方法**简单明了，但效率不高。
 *  **双重检查锁定**较为复杂，但在实例已经创建之后调用`getInstance()`方法无需再进行同步。
 *  **静态内部类**提供懒加载，且不需要同步，是一种比较优雅的实现方式。
 *  **枚举**实现方式可能是实现线程安全单例模式的最佳方法，但缺乏灵活性，并且在某些情况下可能过于简单。

选择哪一种方式取决于具体的场景和需求。在实现时，应该考虑实现的复杂性，性能需求，以及是否需要延迟初始化。

### 4、有哪些方式可以破坏单例模式？怎么预防 ###

单例模式旨在确保一个类只有一个实例，并提供一个全局访问点。然而，有几种方法可以破坏单例模式：

#### 破坏方式： ####

1.  **反射**：通过反射的方式可以访问私有构造函数，从而创建额外的实例。
2.  **序列化与反序列化**：如果单例实现了`Serializable`接口，那么反序列化时可能会创建一个新的实例。
3.  **多线程**：在多线程环境下，如果没有正确实现单例，可能会创建多个实例。
4.  **克隆**：如果单例类实现了`Cloneable`接口，通过克隆方法可以创建额外的实例。
5.  **类加载器**：不同的类加载器可以加载同一个类的多个实例。如果单例类被不同的类加载器加载，那么每个类加载器都会创建一个单例实例。

#### 预防措施： ####

1.  **防止反射破坏**：
    
     *  在构造函数中添加逻辑，如果已经创建了实例，则阻止创建新的实例。
     *  抛出异常，当第二次调用构造函数时，说明有人试图通过反射创建第二个实例。
    
        public class Singleton {
              
            private static final Singleton INSTANCE = new Singleton();
        
            private Singleton() {
              
                if (INSTANCE != null) {
              
                    throw new IllegalStateException("Instance already created!");
                }
            }
        
            public static Singleton getInstance() {
              
                return INSTANCE;
            }
        }
2.  **防止序列化破坏**：
    
     *  实现`readResolve()`方法，返回单例对象，防止反序列化生成新的实例。
    
        protected Object readResolve() {
              
            return getInstance();
        }
3.  **多线程安全**：
    
     *  如前文所述，使用同步机制（如双重检查锁定）来确保线程安全。
4.  **防止克隆破坏**：
    
     *  重写`clone()`方法，并抛出异常或直接返回单例实例。
    
        @Override
        protected Object clone() throws CloneNotSupportedException {
              
            throw new CloneNotSupportedException();
        }
5.  **类加载器隔离**：
    
     *  确保应用中所有使用单例的地方都是通过相同的类加载器来加载的。
     *  对于Java EE环境，通常应用服务器会为每个应用使用独立的类加载器，因此需要注意不要跨越应用访问单例。

通过采取这些预防措施，可以有效地保护单例模式不被破坏，确保全局只有一个实例存在。然而，需要注意的是，即便使用了上述方法，某些情况下单例模式也可能会被破坏（例如，通过修改私有成员变量的值）。因此，在设计单例时，还应该根据具体情况考虑额外的保护措施。

### 5、单例模式会不会导致内存泄漏？为什么？ ###

单例模式确实有可能导致内存泄漏，但这主要取决于单例的使用方式和应用程序的环境。以下是一些可能导致内存泄漏的场景以及背后的原因：

#### 1. 长生命周期和短生命周期对象的关联 ####

单例通常具有和应用程序相同的生命周期，即从程序开始运行时创建，到程序结束时销毁。如果单例持有对其他短生命周期对象的引用（如临时对象或可回收资源），并且未能在不再需要时释放这些对象，那么这些短生命周期对象将不能被垃圾回收，因为它们被单例对象的长生命周期引用所持有，这会导致内存泄漏。

**预防措施**：确保单例不持续持有那些不再需要的对象的引用。可以通过设置为`null`或使用`WeakReference`来避免这种情况。

#### 2. 单例与类加载器 ####

在Java中，如果一个单例由一个类加载器加载，它会被这个类加载器持有，直到类加载器被垃圾回收。如果单例持有对某些资源的引用，而这个类加载器的生命周期比应用程序的某些部分要长，那么这些资源可能不会在适当的时间被释放，导致内存泄漏。

**预防措施**：注意单例和类加载器的关系。在使用单例时，确保处理好与资源的关联关系，并适时释放资源。

#### 3. 静态字段导致的内存泄漏 ####

由于单例的实例通常是作为静态字段存储的，所以如果这个实例引用了应该被垃圾回收的对象，这些对象也不会被回收。

**预防措施**：类似于第一点，不要让单例持有无用的对象引用，或者使用`WeakReference`。

#### 4. 全局状态和上下文泄漏 ####

单例可能会不当地存储应用程序上下文（如Android中的`Context`），而这些上下文在某些情况下可能包含对Activity等资源的引用。如果Activity被销毁，而单例仍持有对它的引用，那么这个Activity及其所有视图和资源都不会被回收，从而导致内存泄漏。

**预防措施**：避免在单例中存储对全局状态或上下文的引用；如果必须这么做，使用应用程序级别的上下文，或确保引用不会超出其生命周期。

#### 5. 事件监听器和回调 ####

单例可能会注册事件监听器或回调，如果在不需要时没有注销它们，这可能会阻止引用它们的对象被垃圾回收。

**预防措施**：当不再需要监听器或回调时，确保它们被注销。

#### 总结 ####

内存泄漏不是单例模式独有的问题，但由于单例的全局访问性和长生命周期特性，不当的使用或管理确实可能导致内存泄漏。开发者应该注意合理管理单例持有的资源，避免在单例中维护不必要的对象引用，并在适当的时候清理资源。设计单例时考虑内存管理是非常重要的，以确保应用程序的性能和稳定性。

### 6、单例模式能否与工厂模式结合使用？如果可以，应该如何实现？ ###

单例模式和工厂模式确实可以结合使用。单例模式用于确保某个类只有一个实例，而工厂模式用于创建对象，尤其是当对象的创建过程复杂或需要依赖注入时。将这两个模式结合使用时，通常是希望通过工厂方法或抽象工厂来创建一个单例对象。

以下是一个简单的例子展示了如何将单例模式与工厂模式结合：

#### 单例工厂实现 ####

这里，我们定义一个工厂接口，以及一个具体的工厂类，这个具体的工厂类是单例的。

// 工厂接口
    public interface ProductFactory {
        
        Product createProduct();
    }
    
    // 单例的具体工厂
    public class SingletonProductFactory implements ProductFactory {
        
        private static SingletonProductFactory instance;
    
        private SingletonProductFactory() {
        
            // 私有构造函数，防止外部直接创建实例
        }
    
        public static synchronized SingletonProductFactory getInstance() {
        
            if (instance == null) {
        
                instance = new SingletonProductFactory();
            }
            return instance;
        }
    
        @Override
        public Product createProduct() {
        
            // 实现创建产品实例的逻辑
            return new ConcreteProduct();
        }
    }
    
    // 产品接口
    public interface Product {
        
        void use();
    }
    
    // 具体产品类
    public class ConcreteProduct implements Product {
        
        @Override
        public void use() {
        
            // 具体使用产品的逻辑
        }
    }

在这个示例中，`SingletonProductFactory`是一个单例，可以用来创建`Product`实例。通过确保`SingletonProductFactory`是单例的，我们能保障全局只有一个工厂实例在创建产品实例，这对于管理资源和配置很有用。

#### 单例中使用工厂方法 ####

另一种结合这两个模式的方式是在单例中使用工厂方法来创建对象。这种情况下，单例类自己内部可能需要创建一些复杂对象，使用工厂方法可以使单例类的代码更加清晰。

// 单例类
    public class Singleton {
        
        private static Singleton instance = new Singleton();
    
        private Singleton() {
        
            // 私有构造函数
        }
    
        public static Singleton getInstance() {
        
            return instance;
        }
    
        // 工厂方法
        public Product createProduct() {
        
            // 创建产品的逻辑
            return new ConcreteProduct();
        }
    }

在这种结合使用的情况下，单例不仅控制自己的实例化过程，还负责生产一些对象的实例化过程。这样做的好处是可以集中对象的创建逻辑，便于维护和替换对象的具体实现。

#### 总结 ####

结合使用单例模式和工厂模式可以为应用程序提供全局的、统一的对象创建服务，同时保证这个服务的唯一性。这种模式的组合可以在需要控制产品创建过程的同时，确保服务的一致性和可管理性。然而，这种结合也可能引入单一职责原则的问题，因为单例类现在既要管理自己的实例，又要负责创建其他对象，这可能会导致类的职责过于庞大。设计时应确保这种结合不会导致代码过于复杂，且符合设计原则。

### 7、什么是懒加载？单例模式如何实现懒加载？ ###

懒加载（Lazy Loading），也称为延迟加载，是一种设计模式，通常用于延迟对象的创建或者某些计算，直到它的第一次使用或实际需要之时。在单例模式中，懒加载意味着单例实例将在第一次需要时创建，而不是在应用程序启动时。

这样做有几个好处：

1.  **资源利用率提高**：避免了在启动时创建不会立即使用的对象，从而减少了应用程序的启动时间和内存占用。
2.  **性能优化**：如果对象从未被使用，则不会创建，从而节省资源。
3.  **控制实例化时间**：可以更好地控制实例化的过程和时间点。

在Java中，实现单例模式的懒加载通常有多种方式，这里举例两种常见的实现：

#### 1. 懒汉式（线程不安全） ####

这是最基本的懒加载实现方式。它在类装载时不创建实例，而在需要时创建实例。

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

该方法的缺点是它不是线程安全的。如果多个线程同时访问`getInstance()`方法，可能会创建多个实例。

#### 2. 懒汉式（线程安全） ####

为了使懒汉式实现线程安全，通常需要添加同步锁`synchronized`。

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

这种方式虽然线程安全，但每次访问`getInstance()`方法时都需要进行同步，这会导致不必要的同步开销，降低效率。

#### 3. 双重检查锁定（Double-checked locking） ####

为了提高性能，可以使用双重检查锁定模式，它在`getInstance()`中进行两次`null`检查，这样就可以在不需要同步的时候避免执行同步方法。

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

使用`volatile`关键字是因为它可以防止JVM指令重排，确保在对象初始化完成前不会分配内存地址。

#### 4. 静态内部类 ####

静态内部类可以提供线程安全的懒加载实现，推荐使用。

public class Singleton {
        
        private Singleton() {
        
        }
    
        private static class SingletonHolder {
        
            private static final Singleton INSTANCE = new Singleton();
        }
    
        public static Singleton getInstance() {
        
            return SingletonHolder.INSTANCE;
        }
    }

在这种方法中，`SingletonHolder`类在第一次被加载时不会初始化`INSTANCE`，只有在第一次调用`getSingleton()`方法时，虚拟机加载`SingletonHolder`类并初始化`INSTANCE`。这种方式不仅能保证线程安全，也能保证单例的唯一性，同时延迟了单例的实例化。

以上就是在单例模式中实现懒加载的几种方式，每种方式都有其适用的场景和权衡的考虑。

### 8、双重校验锁是什么？它如何在单例模式中工作？ ###

双重校验锁（Double-Checked Locking，简称DCL）是一种多线程设计模式，用于减少同步的开销。双重校验锁在单例模式中的应用是确保只有一个单例实例被创建，同时保持高效的并发访问。

这种模式的核心在于，只有在创建实例时才进行同步，这样一旦实例被创建，就不需要再进行同步处理了，因为你只需要在第一次创建对象时同步，以后的访问都不必同步，进而提高了性能。

下面是单例模式中使用双重校验锁的一个例子：

public class Singleton {
        
        // 使用volatile关键字确保多线程情况下的可见性和有序性
        private volatile static Singleton instance;
    
        private Singleton() {
        
            // 私有构造函数
        }
    
        public static Singleton getInstance() {
        
            // 第一次检查：如果实例已经被创建，直接返回已有的实例
            if (instance == null) {
        
                // 同步块，只在实例未初始化时进入
                synchronized (Singleton.class) {
        
                    // 第二次检查：确保只有一个线程能够进入实例创建区块
                    if (instance == null) {
        
                        instance = new Singleton();
                    }
                }
            }
            return instance;
        }
    }

这里是如何工作的：

1.  **第一次检查**：检查`instance`是否已经被实例化，如果已经实例化，则不需要进入同步块，这就是所谓的“懒加载”。
2.  **同步块**：如果`instance`是`null`，则进入同步块。注意，同步块是同步在`Singleton.class`上的，这确保了每次只有一个线程可以进入到创建实例的代码区。
3.  **第二次检查**：在同步块内再次检查`instance`是否为`null`，这是因为可能有多个线程同时通过了第一次检查，并等待进入同步块。如果不进行第二次检查，那么每个线程都会创建一个实例，这样就违背了单例模式的原则。
4.  **实例化**：如果第二次检查仍然是`null`，则创建Singleton的新实例。
5.  **volatile关键字**：使用`volatile`的原因是防止指令重排序。在某些情况下，JVM可能会对对象的初始化进行优化，导致`instance`的引用在对象的所有构造函数执行完毕之前就已经被设置了，如果没有`volatile`，其他线程可能访问到一个未完全构造的对象。

总之，双重校验锁是一种实现单例模式的高效方法，它在多线程情况下保证了安全性，并且在对象已经创建之后，避免了同步带来的性能开销。然而，需要注意的是，DCL的正确实现在Java中需要使用`volatile`关键字，这在Java 5及以上版本才被正确实现。在此之前的Java版本中，可能会由于JVM内存模型的原因导致DCL工作不正确。

### 9、为什么说使用枚举来实现单例模式是最佳方法？请举例说明。 ###

在Java语言中，使用枚举（Enumerations）来实现单例模式被认为是最简洁、安全的方法之一。枚举类型的单例实现可以避免多线程同步问题，还能防止反序列化重新创建新的对象，同时写法简洁。

这里有几个原因让枚举成为实现单例的最佳方法：

1.  **线程安全**：Java虚拟机在加载枚举类的时候会使用类加载机制，保证枚举实例的唯一性和线程安全性。
2.  **写法简洁**：不需要自己去编写用来保证单例的代码。
3.  **防止反序列化创建新的实例**：枚举的反序列化会通过`java.lang.Enum`的`valueOf()`方法来返回枚举常量，而不是创建新的实例。
4.  **防止反射攻击**：枚举类的构造函数默认是私有的，反射不能够用来创建枚举类型实例的新对象。

下面是使用枚举实现单例的一个典型例子：

public enum Singleton {
        
        INSTANCE;
    
        public void doSomething() {
        
            // Perform operation here
        }
    }

使用时非常简单：

public class SingletonDemo {
        
        public static void main(String[] args) {
        
            Singleton.INSTANCE.doSomething();
        }
    }

在这个例子中，`Singleton`类型有一个名为`INSTANCE`的枚举常量，它代表了Singleton的唯一实例。你可以通过`Singleton.INSTANCE`来访问单例，这种方法是完全线程安全的，并且在任何情况下，都不可能创建出另一个`Singleton`实例。

这种方法在Java 1.5之后被广泛认可为实现单例的最佳方法，尤其是当单例需要通过序列化传输或者在高并发场景下使用时。在枚举单例的实现中，只有一个枚举常量`INSTANCE`，JVM会保证该实例的唯一性。不同于其他方法，枚举类型的单例模式无需担心序列化和反射的问题。

### 10、单例模式有哪些优点和缺点？ ###

单例模式是一种常用的设计模式，确保了一个类只有一个实例，并提供一个全局访问点来获取这个实例。以下是单例模式的一些优点和缺点：

#### 优点： ####

1.  **资源控制**：单例可以控制资源的使用，通过确保只有一个实例减少了对内存和系统资源的消耗。
2.  **全局访问点**：单例对象可以从程序的任何位置被访问，而不需要将对象在各处传递。
3.  **共享实例**：可以方便地共享和重用单个对象，很多时候用于访问共享资源，如配置信息、硬件接口等。
4.  **控制实例化**：单例模式可以更精确地控制何时和如何访问资源。
5.  **减少名称空间污染**：由于单例对象只实例化一次，因此它们可以减少全局变量的使用，从而减少名称空间的污染。

#### 缺点： ####

1.  **全局依赖**：单例对象的全局状态可能导致代码之间不适当的耦合，使得代码难以阅读和维护。
2.  **测试困难**：单例模式的全局状态会使得单元测试很难执行，因为它们难以被模拟和隔离。
3.  **不适应变化**：如果应用程序在未来需要多个实例，则单例模式可能会成为改变的障碍。
4.  **生命周期问题**：单例的生命周期通常由程序全局管理，它们在整个应用程序生命周期内都存在，这可能导致对象的生命周期过长，并产生内存泄漏等问题。
5.  **多线程问题**：如果不正确实现，单例在多线程应用程序中可能会导致并发问题。

总结起来，单例模式在确保资源控制和减少内存开销方面具有优势，但可能会增加代码耦合度和难以测试的问题。使用单例模式时，应当仔细考虑其在当前和未来上下文中的适用性。

### 11、单例模式的实际使用场景 ###

单例模式在软件开发中有很多实际的使用场景，尤其是在需要控制资源访问或者保证一致性的时候。以下是一些常见的单例模式使用场景：

1.  **配置管理**：用于管理应用程序的配置信息。通常，配置信息在系统启动时加载，并在整个生命周期中被多处组件共享。
2.  **日志记录**：日志记录类通常被设计成单例，以保证全局只有一个日志记录器被创建，它可以被应用程序中的所有组件访问来记录日志。
3.  **数据库连接池**：数据库连接是一种稀缺资源，使用单例模式可以保证全局只有一个数据库连接池，以便控制数据库连接的数量和管理。
4.  **硬件接口访问**：对于硬件资源如打印机或文件系统等的访问，单例可以确保在任何时候只有一个实例与之通信，避免了资源冲突。
5.  **缓存**：应用程序的缓存通常也是单例模式的一个例子，例如，内存中的缓存，它可以被应用程序的不同部分所共享和访问。
6.  **线程池**：线程池的管理通常会使用单例模式，因为线程池在整个应用程序中是唯一的，并且需要被多个客户共享。
7.  **应用程序中的服务类**：例如，如果有一个用于执行特定任务的服务类，可能需要确保它的行为不会被多个实例中的不一致状态所影响。
8.  **游戏的管理组件**：在游戏开发中，经常会有一些管理游戏状态或者提供游戏全局服务的组件，这些组件也常被设计为单例。
9.  **操作系统提供的服务**：如窗口管理器或文件系统，这些通常也会被设计成单例，以保证整个系统中只有一个实例。
10. **驱动对象**：对于一些需要与操作系统交互的驱动程序，通常只需要一个实例，因此它们也可以通过单例模式来实现。

在使用单例模式时，开发者需要注意其对测试和系统设计的影响。单例模式可能会降低系统的灵活性，并且可能使得代码更加难以测试。因此，推荐在真正需要全局状态或者严格控制资源的情况下使用单例模式。

### 12、单例实例会被垃圾回收器回收吗？为什么？ ###

在Java中，单例实例通常是不会被垃圾回收器（GC）回收的，主要原因是单例模式的设计意图是在程序的整个生命周期内保持只有一个实例。

具体来说，单例的一个实例被私有静态成员变量所引用。在Java中，静态成员变量属于类级别的，它们的生命周期和类的加载、卸载一致。只要类没有被卸载，这些静态成员变量就会一直保持在内存中，也就不会成为垃圾回收器的回收目标。

下面是一个单例实现的例子：

public class MySingleton {
        
        private static MySingleton instance = new MySingleton();
    
        private MySingleton() {
        
            // 私有构造函数
        }
    
        public static MySingleton getInstance() {
        
            return instance;
        }
    
        // 其他方法...
    }

在这个例子中，只要`MySingleton`类没有被卸载，`instance`因为被`getInstance()`方法静态引用，所以它不会被GC回收。

在一些特定的情况下，单例可以被回收，例如：

1.  **类卸载**：如果一个类加载器被回收，那么由这个类加载器加载的类以及类的静态变量都会被GC回收。这在JavaEE环境或者热部署的场景中可能会发生。
2.  **单例实现方式**：如果单例是通过实例的弱引用实现的，这种特殊情况下，当JVM感觉到内存紧张时，这个单例实例是可以被GC回收的。

尽管单例实例通常不会被GC回收，但是也应当注意资源管理和程序设计，以防止内存泄露或者无法预料的单例状态。

### 13、单例模式与全局变量有什么区别？ ###

单例模式和全局变量都提供了在不同的代码区域共享数据的方法，但它们的设计意图、使用方式以及引入的问题有很大的不同。

#### 单例模式： ####

1.  **控制实例化**：单例模式控制了类的实例化过程，确保了全局只有一个实例。这个实例的创建是受控的，通常是懒加载的（即在第一次需要时才创建）。
2.  **封装**：单例对象的内部状态是通过实例方法来访问和修改的，这意味着单例可以对其状态实施封装和访问控制。
3.  **可继承**：虽然继承单例类通常不是一个好主意，但从理论上讲，单例类可以继承或实现接口，而全局变量则不能。
4.  **延迟初始化**：如果单例实例化有显著的计算开销或需要大量资源，单例模式可以延迟这个过程直到首次使用。
5.  **接口实现**：单例可以实现一个或多个接口，如果需要可以通过接口来引用单例，这为替换实现、测试、依赖注入等提供了可能。

#### 全局变量： ####

1.  **随时可用**：全局变量通常在程序启动时就被分配空间，随时可以访问，不需要通过任何特殊的创建过程。
2.  **命名空间污染**：全局变量直接暴露在全局命名空间中，这可能导致命名冲突和代码可读性问题。
3.  **无封装**：全局变量可以被任何人从任何地方访问和修改，这增加了代码的脆弱性，因为很难追踪全局变量的所有访问和修改。
4.  **难以控制生命周期**：全局变量的生命周期通常很难控制，它们从程序开始时创建到程序结束时才销毁。
5.  **不支持接口和继承**：全局变量无法实现接口或被继承，它们是静态的数据存储，不具备对象的行为。

总的来说，单例模式提供了更多的控制性和灵活性。它通过确保只有一个实例存在并通过方法调用来访问和修改数据，保留了面向对象设计的好处。而全局变量则是简单的数据存储，易于使用但难以维护，且可能导致代码质量问题。在实际开发中，优先考虑使用单例模式而不是全局变量，可以提高代码的健壮性和可维护性。

### 14、 ###