java中的单例模式举例

最新推荐文章于 2024-09-04 16:54:18 发布

黑白的格调

最新推荐文章于 2024-09-04 16:54:18 发布

阅读量567

点赞数 17

分类专栏： java知识点文章标签： java

本文链接：https://blog.csdn.net/qq_42907608/article/details/141322444

版权

java知识点专栏收录该内容

4 篇文章 0 订阅

订阅专栏

java中的单例模式举例

饿汉式单例模式

饿汉式单例模式：是一种在类加载时就创建实例的单例模式实现方式。由于实例在类加载时就被创建，因此它是线程安全的。

public class Esingleton {

    // 在类加载时就创建实例
    private static final Esingleton instance = new Esingleton();

    // 是私有化构造函数，防止外部实例化
    private Esingleton(){
        // 初始化代码
        System.out.println("初始化代码");
    }

    // 提供公共的静态代码方法获取实例
    public static Esingleton getInstance(){
        return instance;
    }

    // 其他方法
    public void dosomething(){
        System.out.println("Singleton instance is doing something.");
    }

    public static void main(String[] args) {
        /**
         * 在这个示例中：
         * 1、私有构造函数：Esingleton 类的构造函数私有化，这样外部无法通过 new 关键字创建实例。
         * 2、静态实例：在类加载时，静态变量 instance 被初始化为 Esingleton 类的一个实例。
         * 3、公共静态方法：提供一个公共的静态方法 getInstance(),用于返回唯一的实例。
         * */

        Esingleton instance1 = Esingleton.getInstance();
        instance1.dosomething();

        Esingleton instance2 = Esingleton.getInstance();
        instance2.dosomething();

        // 验证两个实例是否相同
        System.out.println(instance1 == instance2); // 输出true
    }

}

总结：

饿汉式单例模式的优点是实现简单且线程安全，但由于实例在类加载时就创建，可能会导致资源浪费，特别是在实例初始化比较耗时或资源占用较大的情况下。

懒汉式单例模式

懒汉式单例模式：在需要时才创建实例，而不是在类加载时创建。这样可以延迟实例化，避免资源浪费。但是，需要注意线程安全问题。

1. 线程不安全的懒汉式单例模式

public class UnsafeLazySingleton {

    // 静态变量保存单例实例
    private static UnsafeLazySingleton instance;

    // 私有化构造函数，防止外部实例化
    private UnsafeLazySingleton(){
        // 初始化代码
    }

    // 提供公共的静态方法获取实例（如果多个线程同时调用 `getInstance()` 方法，可能会创建多个实例。）
    public static UnsafeLazySingleton getInstance(){
        if (instance == null){
            instance = new UnsafeLazySingleton();
        }
        return instance;
    }
}

2. 使用 `synchronized` 方法确保线程安全

通过在方法上添加 synchronized 关键字，确保在多线程环境下的线程安全。

缺点：由于每次获取实例都需要进行同步，可能会影响性能。

public class SynchronizedLazySingleton {
    private static SynchronizedLazySingleton instance;

    private SynchronizedLazySingleton(){
        // 初始化代码
    }

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

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

双重检查锁定是一种优化技术，减少了同步的开销。

在这种实现中，只有在 instance 为 null 时才会进行同步，减少了同步的开销。

public class DoubleCheckedLockSingleton {
    // 使用 volatile 关键字确保 instance 可见性和禁止指令重排
    private volatile static DoubleCheckedLockSingleton instance;

    private DoubleCheckedLockSingleton(){}

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

4. 静态内部类实现懒汉式单例（推荐）

使用静态内部类可以实现懒加载，并且利用jvm的类加载机制保证线程安全。

public class InsideSingleton {
    private InsideSingleton(){}

    // 静态内部类
    private static class SingletonHolder{
        // 创建外部类对象
        private static final InsideSingleton INSTANCE = new InsideSingleton();
    }

    // 提供公共静态方法访问实例
    public static InsideSingleton getInstance(){
        return SingletonHolder.INSTANCE;
    }

    public static void main(String[] args) {
        // 在这种实现中，singletonHolder 类只有在 getInstance() 方法第一次被调用时才会被加载，从而实现了懒加载。jvm在类加载时会保证初始化的线程安全。
        InsideSingleton instance = InsideSingleton.getInstance();
        InsideSingleton instance1 = InsideSingleton.getInstance();
        // 验证两个实例对象是否相同
        System.out.println(instance == instance1);// true
    }
}

java类中的静态方法的加载时机

在Java中，类的静态方法和静态变量的加载时机是由JVM在类加载阶段进行的。具体来说，类的静态方法和静态变量会在类被第一次使用时加载，通常包括以下几种情况：

类的实例化：当你第一次创建类的实例时，类的静态方法和静态变量会被加载。
访问类的静态变量：当你第一次访问类的静态变量时，类会被加载。
调用类的静态方法：当你第一次调用类的静态方法时，类会被加载。
类被反射调用：当你通过反射机制来访问类时，类会被加载。

public class MyClass {
    static {
        System.out.println("MyClass static block executed.");
    }

    public static int staticVar = initializeStaticVar();

    private static int initializeStaticVar() {
        System.out.println("Static variable initialized.");
        return 88;
    }

    public static void staticMethod(){
        System.out.println("Static method called.");
    }

    public MyClass(){
        System.out.println("MyClass constructor called.");
    }


    public static void main(String[] args) {
        // 1、类的实例化
        MyClass instance = new MyClass();// 触发类加载
        // 输出结果
        /**
                MyClass static block executed.
                Static variable initialized.
                MyClass constructor called.
         */


        // 2、访问类的静态变量
        int value = MyClass.staticVar;// 触发类加载
        // 输出结果
        /**
                 MyClass static block executed.
                 Static variable initialized.
         */


        // 3、调用类的静态方法
        MyClass.staticMethod();// 触发加载
        // 输出结果
        /**
                 MyClass static block executed.
                 Static variable initialized.
                 Static method called.
         */


        // 4、类被反射调用
        try {
            Class.forName("MyClass");
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
        // 输出结果
        /**
                 MyClass static block executed.
                 Static variable initialized.
         */
    }
}