单列模式

20lxj666 / 2024-09-18 / 原文

单列模式

“单例模式（Singleton Pattern），用于确保一个类只有一个实例，并提供一个全局访问点来访问这个实例。这个模式在需要控制资源的访问或者确保某些操作只有一个实例时使用。

单例模式的特点

唯一性：保证一个类只有一个实例。
全局访问：提供一个全局的访问点来获取这个实例。
延迟初始化：可以在第一次需要时才创建实例（懒汉式），或在程序启动时就创建实例（饿汉式）。

实现方式

饿汉式：

在类加载时就创建实例。
线程安全，但可能在不需要时就创建了实例。

public class Singleton {
    private static final Singleton instance = new Singleton();
    
    private Singleton() {}
    
    public static Singleton getInstance() {
        return instance;
    }
}

懒汉式：

在第一次使用时才创建实例。
需要注意线程安全问题。

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

静态内部类

结合了懒汉式和饿汉式的优点。在 Java 中被认为是一种优雅且高效的单例实现方式，因为它利用了 Java 的类加载机制和静态内部类的特性来实现延迟初始化和线程安全。

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

双重检查锁（DCL）：

在懒汉式基础上优化，提高性能和线程安全。

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;
    }
}

枚举式：

Java推荐的单例实现方式，简单且线程安全。

public enum Singleton {
    INSTANCE;
}

测试代码

import java.util.Set;
import java.util.concurrent.CopyOnWriteArraySet;
//单列模式
public class TestSingleton {

    // 使用线程安全的 Set 来存储实例的哈希码
    private static final Set<Integer> hashCodes = new CopyOnWriteArraySet<>();
    public static void main(String[] args) {
        // 创建一个线程数组
        Thread[] threads = new Thread[100];

        // 启动多个线程来测试 CreativeMode.SingletonPattern.DoubleLocking.Singleton
        for (int i = 0; i < threads.length; i++) {
            threads[i] = new Thread(() -> {

                Singleton instance = Singleton.getInstance();
//                Singleton instance = Singleton.INSTANCE; //枚举使用这个
                hashCodes.add(instance.hashCode()); // 添加实例的哈希码到线程安全的集合
            });
            threads[i].start();
        }

        // 等待所有线程完成
        for (Thread thread : threads) {
            try {
                thread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        // 打印去重后的哈希码
        System.out.println("-------------------------");
        for (Integer hashCode : hashCodes) {
            System.out.println(hashCode);
        }
    }
}