笔试-单例模式

在 Java 中，单例模式（Singleton Pattern）是一种创建型设计模式，它确保一个类只有一个实例，并提供一个全局访问点来获取这个实例。单例模式常用于资源密集型的对象，例如数据库连接、线程池等。以下是几种实现单例模式的方式。

1.枚举（推荐）

Effective Java 作者推荐的一种单例实现方式，简单高效，无需加锁，线程安全，可以避免反射破坏枚举单例。

public enum Signleton{
    INSTANCE;
    public void doSomething(String str){
        System.out.println(str);
    }
}

INSTANCE 是枚举类型 Singleton 的唯一实例

使用方式:

在代码的其他地方，使用单例时只需通过 Singleton.INSTANCE 来访问枚举实例，调用它的方法或操作它的属性：

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

2.静态内部类（推荐）

当外部类 Singletion 被加载的时候，并不会创建静态内部类 SingletonHelper 的实例对象，只有 Singleton 调用 getInstance（）方法的时候，SingletonHelper 才会被加载，这个时候才会创建单例对象 INSTANCE。INSTANCE 的唯一性、创建过程的线程安全性，都由 JVM 来保证实现。

public class Singleton {
​
    // 私有化构造函数
    private Singleton() {}
​
    // 静态内部类，用于创建实例
    private static class SingletonHelper {
        private static final Singleton INSTANCE = new Singleton();
    }
​
    // 提供一个全局访问点
    public static Singleton getInstance() {
        return SingletonHelper.INSTANCE;
    }
}
​

这种方式简单高效，不需要加锁，线程安全，并且支持延时加载。

3.饿汉式 (Eager Initialization)

饿汉式在类加载时就创建了单例实例，这是最简单的一种单例实现方式。

public class Singleton {
    // 在类加载时创建实例
    private static final Singleton instance = new Singleton();
​
    // 私有化构造函数，防止外部实例化
    private Singleton() {}
​
    // 提供一个全局访问点
    public static Singleton getInstance() {
        return instance;
    }
}

优点:

• 实现简单。

• 没有加锁，执行效率高。

缺点:

• 类加载时就实例化，可能造成资源浪费（如果实例一直没有被使用）。

4.懒汉式 (Lazy Initialization)

懒汉式在需要时才创建实例，即在第一次调用 getInstance() 时实例化。

public class Singleton {
    // 静态变量存储唯一实例
    private static Singleton instance;
​
    // 私有化构造函数
    private Singleton() {}
​
    // 提供一个全局访问点，并在需要时创建实例
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

优点:

• 延迟加载，只有在需要时才会创建实例，节省资源。

缺点:

• 使用 synchronized 加锁，导致每次获取实例时都需要进行同步，性能可能较低。

5.双重检查锁定 (Double-Checked Locking)

双重检查锁定是对懒汉式的一种优化，它减少了 synchronized 带来的性能开销。

public class Singleton {
    // 使用 volatile 保证 instance 在多线程环境下的可见性
    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;
    }
}

当我们使用 synchronized (Singleton.class) 时，我们是对 Singleton 类的 Class 对象进行加锁。这意味着在同一时间内，只有一个线程可以进入由 synchronized 保护的代码块。

优点:

• 线程安全，性能开销较小。

• 实现了延迟加载。

缺点:

• 实现复杂，可能会让代码难以理解。

总结

• 静态内部类 是一种更优雅的延迟加载单例实现方式。

• 枚举 是最安全、简洁的单例实现方式，适用于绝大多数场景。

• 饿汉式 适合对资源浪费不敏感且确定会使用的单例对象。

• 懒汉式 适合资源密集的对象，但要注意线程安全问题。

• 双重检查锁定 提供了性能优化，但实现复杂。

补充 static的用法

static 是 Java 中的一个关键字，用于声明类的成员（包括变量、方法、内部类等）为静态的。static 关键字有多种用法，并且在不同的场景中具有不同的意义和作用。下面详细解释 static 的用法。

1. 静态变量（static 变量）

• 定义: 静态变量在内存中只存在一份。

• 共享性: 所有实例对象共享同一个静态变量的值。

• 生命周期: 静态变量在类加载时初始化，并在 JVM 停止运行时销毁。

• 访问方式: 静态变量可以通过类名直接访问，也可以通过对象访问（不推荐）。

1. 静态方法（static 方法）

• 限制: 静态方法只能访问静态变量和调用静态方法

• 访问方式: 静态方法可以通过类名直接调用。

1. 静态块（static 块）

• 执行时机: 静态块在类第一次加载到内存时执行，并且只执行一次。

• 作用: 常用于对静态变量进行复杂的初始化，或者执行某些只需执行一次的操作。

1. 静态内部类（static 内部类）

• 访问方式: 静态内部类可以直接访问外部类的静态变量和静态方法，但不能访问外部类的非静态成员。

1. 静态导入（static import） 了解即可

• 定义: 静态导入允许我们在不使用类名限定的情况下访问类的静态成员（变量或方法）。

• 用法: 可以简化代码的书写，但使用时要注意可读性和命名冲突问题。

总结

• static 关键字 用于声明类成员与实例无关，属于类本身。

• static 变量 是所有实例共享的，在类加载时初始化。

• static 方法 可以在没有对象实例的情况下调用，但只能访问其他静态成员。

• static 块 用于静态成员的初始化，且在类加载时执行一次。

• static 内部类 是与外部类实例无关的嵌套类，可以直接访问外部类的静态成员。

• 静态导入 简化了静态成员的访问，但要注意潜在的命名冲突。