单例模式之饿汉式

news2024/9/22 4:15:40

1 单例模式的程序结构

2 饿汉式单例模式的实现

3 饿汉式线程安全

4 防止反射破坏单例

5 总结

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。所谓单例就是在系统中只有一个该类的实例，并且提供一个访问该实例的全局访问方法。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式，关于单例模式的原理，可参考文末的链接文章。

单例的实现分为三个步骤：

构造方法私有化。即不能在类外实例化，只能在类内实例化。
在本类中完成自身的初始化，自己创建本类的实例，且是唯一的实例。
在本类中提供给外部获取实例的方式，提供访问该实例的全局静态方法getInstance()，来获取该类的唯一实例引用。

单例模式的特点：从系统启动到终止，整个过程只会产生一个实例。因为单例提供了唯一实例的全局访问方法，所以它可以优化共享资源的访问，避免对象的频繁创建和销毁，从而可以提高性能。单例模式常见的应用场景如下：Windows任务管理器、数据库连接池、Java中的Runtime、Spring中Bean的默认生命周期等。

1 单例模式的程序结构

单例模式简化后的类图如下所示：

类图显示了该类的一个私有静态成员变量、一个公有静态方法（又叫静态成员函数）以及一个私有的构造函数。虽然这是简化后的结构，但也是单例模式的主要结构。顺便说一下，这个类图只是个简化后的结构，该类通常还会有其它的非静态的成员变量和方法，当获取到该类的唯一实例后，就在该实例上调用这些其它方法来执行该类提供的功能。

私有的构造函数保证只能在类内部实例化；静态成员变量用来保存该类的唯一实例，该静态成员变量必须是private的，以防止用户可以直接访问到它。如果用户想要访问该单例类的唯一实例，它只能调用该类的静态方法（getInstance）。

注意static（静态成员变量、静态方法）的使用。从语法上来说，创建的单例类是不允许被其他程序用new来创建该对象的，所以只能将这个单例类中的方法定义成静态的，而静态方法又不能去访问非static成员的，所以因此类自定义的实例变量也必须是静态的。

这里不妨回顾一下，静态成员变量是属于整个类的，仅在类的初次加载时初始化，在类被销毁时才会被回收。通过该类实例化的所有对象都共享该静态变量，任一对象对于该静态变量的修改都会影响所有的对象。静态方法同样是属于整个类的，可以通过类名与对象名进行访问，而非静态成员是随着对象的创建而被实例化的。在调用静态方法时，可能对象还没有实例化，自然也就没有对象的非静态成员的实例化，所以无法访问非静态的成员。

2 饿汉式单例模式的实现

在Java中实现单例模式通常有两种形式.:

饿汉式：类加载时，就进行对象实例化。
懒汉式：第一次引用类时，才进行对象实例化。

这里主要聚焦于饿汉式。饿汉式代码实现如下：

public class HungrySingLeton {

    // 创建HungrySingLeton 的一个对象
    private static final HungrySingLeton instance = new HungrySingLeton();

    // 让构造函数为private，这样该类就不会被实例化
    private HungrySingLeton() {
    }

    // 获取唯一可用的对象
    public static HungrySingLeton getInstance(){
        return instance;
    }

    /**
     * 获取对象的内存地址
     * @return
     */
    public long getRamAddress() {
        return VM.current().addressOf(this);
    }
}

注意instance变量加了final的，一般建议加final，除非说有释放资源等特殊要求。这种方式简单，也比较常用，在类创建的同时已经创建好一个静态的对象供系统使用，执行效率高。

3 饿汉式线程安全

饿汉式单例通过getInstance获取的单例，在类加载时已经初始化完毕，在多线程环境下也是安全的，所以不需要同步。我们可以通过测试来验证。

先写一个公共方法，用于多线程环境下获取单例：

    /**
     * 公共方法，在多线程环境下获取单例，避免重复编写测试代码
     * @param threadCount  线程数
     * @param func  函数，用于获取单例
     * @param <T>
     */
    public static <T> List<T> getSingLetonObjList(int threadCount, Supplier<T> func) {
        List<T> list = new ArrayList<>();
        ExecutorService executorService = Executors.newFixedThreadPool(threadCount);
        IntStream.range(0, threadCount).forEach(i -> {
            executorService.submit(() -> {
                // 同步锁，保证保证内存的可见性，否则在多线程环境下可能出现空对象
                synchronized (SingletonTest.class) {
                    list.add(func.get());
                }

            });
        });

        executorService.shutdown();

        while(true) {
            // 所有的子线程都结束了
            if(executorService.isTerminated()) {
                if(list.size() == threadCount) {
                    return list;
                }
            }
        }
    }

这个公共方法可以接收一个函数，该函数就是获取单例的方法。值得注意的是那个同步锁，如果不加的话，在多线程环境下，可能会获得空的单例导致后续调用getRamAddress方法时出现空指针。当然，也可以用Sytem.out.print方法代替：

synchronized (SingletonTest.class) {
     list.add(func.get());
}

等价于：

System.out.print("");
list.add(func.get());

因为print方法本身就自带锁：

public void println(String x) {
        synchronized (this) {
            print(x);
            newLine();
        }
}

有了公共方法后，接着写测试代码：

    public static void hungrySingLetonTest() {
        Supplier func = () ->  HungrySingLeton.getInstance();
        List<HungrySingLeton> list = getSingLetonObjList(10, func);
        list.stream().forEach(item -> {
            System.out.println("内存地址: " + item.getRamAddress());
        });

    }

测试结果如下：

多线程下获取到的单例始终是同一个对象，他们的内存地址都一样。

4 防止反射破坏单例

到这里，可能会认为已经很OK了。但是，Java还有个反射机制，通过反射，可以轻易破解单例的安全。

    public static void reflectionTest() throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Class<HungrySingLeton> clazz = HungrySingLeton.class;
        // 获取HungrySingLeton的默认构造函数
        Constructor<HungrySingLeton> constructor = clazz.getDeclaredConstructor();
        constructor.setAccessible(true);
        // 调用默认构造函数创建实例
        HungrySingLeton h1 = constructor.newInstance();
        HungrySingLeton h2 = constructor.newInstance();
        System.out.println(h1.getRamAddress());
        System.out.println(h2.getRamAddress());
    }

得到的结果如下：

是两个对象实例！既然反射是先获得class（也是类的实例），再通过calss获得构造函数，去获取单例，那么解决办法就是在饿汉式构造函数中，同步类：

public class HungrySingLeton {

    // 创建HungrySingLeton 的一个对象
    private final static HungrySingLeton instance = new HungrySingLeton();

    // 让构造函数为private，这样该类就不会被实例化
    private HungrySingLeton() {
        // 防止防止反射破坏单例
        synchronized (HungrySingLeton.class) {
            if(instance != null){
                throw new RuntimeException("单例构造器禁止反射调用");
            }
        }
    }

    // 获取唯一可用的对象
    public static HungrySingLeton getInstance(){
        return instance;
    }

    /**
     * 获取对象的内存地址
     * @return
     */
    public long getRamAddress() {
        return VM.current().addressOf(this);
    }
}

测试结果如下：