Java设计模式之单例模式

在软件工程中，单例模式是一种常用的设计模式，其核心目标是确保一个类只有一个实例，并提供一个全局访问点来获取这个实例。Java作为一门广泛使用的编程语言，实现单例模式是面试和实际开发中的常见需求。本文将深入探讨Java中的单例模式，包括其优缺点分析、实现方式等。

优缺点分析

优点

• 内存利用率高：因为只创建一个实例，减少了内存的开销。
• 性能提高：避免了频繁的创建和销毁对象所带来的性能开销。
• 共享资源：可以方便地共享数据。

缺点

• 不支持有参数的构造函数：单例模式通常不能接受参数，这限制了其使用场景。
• 扩展困难：由于单例模式的特殊性，扩展时需要修改代码，违背了“开闭原则”。
• 隐藏类之间的依赖关系：由于直接使用了单例类，使得类之间的依赖关系不明显。

单例模式的实现

单例模式的实现比较简单，每次获取实例之前先判断其是否存在，不存在则创建，存在则直接返回。单例模式的实例只能由其自身去创建和销毁，不允许其它类通过new关键字去创建。单例模式常见的写法由饿汉式、懒汉式（线程安全）、双重检查锁、静态内部类。以下是这些写法的具体实现。

饿汉式

饿汉式是指在类加载时就完成了实例的初始化，本质上是利用类加载机制保证实例的唯一性和线程安全。

package cn.xj.xjdoc.singleton;

/**
 * 单例模式--饿汉式
 */
public class HungrySingleton {
    private static final HungrySingleton INSTANCE = new HungrySingleton();

    /**
     * 构造方法私有化
     * 保证外部无法直接通过new关键字来创建此类的实例
     */
    private HungrySingleton(){

    }

    /**
     *获取实例的public的静态方法
     */
    public static HungrySingleton getInstance(){
        return INSTANCE;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

懒汉式

懒汉式指全局的单例实例在第一次被使用时构建。为了解决线程安全问题，增加synchronized关键字，使得在同一时刻，只有一个线程能够访问这个方法。

package cn.xj.xjdoc.singleton;

/**
 * 单例模式--懒汉式
 */
public class LazySingleton {

    private static LazySingleton instance;

    /**
     * 构造方法私有化
     * 保证外部无法直接通过new关键字来创建此类的实例
     */
    private LazySingleton(){

    }

    /**
     *获取实例的public的静态方法，
     *使用synchronized锁，保证在同一时刻，只有一个线程能执行该方法，避免了多线程下创建多个实例的问题。
     */
    public static synchronized LazySingleton getInstance(){
        //实例为null则创建实例
        if(instance == null){
            instance = new LazySingleton();
        }

        return instance;
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

双重检查锁

双重检查锁定在懒汉式的基础上做了进一步的优化，既保证了懒加载，又保证了线程安全，同时减少了锁的粒度，提高了性能。

package cn.xj.xjdoc.singleton;

/**
 * 单例模式--双重检查锁
 */
public class DoubleCheckedLockSingleton {

    // 声明一个私有的静态变量instance，并使用volatile关键字修饰。
    // volatile确保instance变量的可见性和禁止指令重排序，对于双重检查锁定模式非常关键。
    private volatile static DoubleCheckedLockSingleton instance;

    /**
     * 构造方法私有化
     * 保证外部无法直接通过new关键字来创建此类的实例
     */
    private DoubleCheckedLockSingleton(){

    }

    /**
     *获取实例的public的静态方法
     */
    public static DoubleCheckedLockSingleton getInstance(){
        // 第一次检查：如果instance不为null，则不需要进入同步块，直接返回实例。
        // 这样做的好处是，只有第一次调用时才会进行同步，之后的调用由于instance已经被实例化，直接返回，提高了效率。
        if(instance == null){
            // 使用synchronized锁，，确保多线程环境下的线程安全
            synchronized (DoubleCheckedLockSingleton.class){
                //实例为null则创建实例
                if(instance == null){
                    instance = new DoubleCheckedLockSingleton();
                }
            }
        }
        return instance;
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

静态内部类

静态内部类单例模式的实现思路是：利用JVM在加载外部类的过程中不会加载静态内部类，只有在内部类被使用时才会被加载。这样不仅能延迟内部类的加载时间，还能保证线程安全。

package cn.xj.xjdoc.singleton;


/**
 * 单例模式--静态内部类
 */
public class StaticNestedClassSingleton {
    /**
     * 构造方法私有化
     * 保证外部无法直接通过new关键字来创建此类的实例
     */
    private StaticNestedClassSingleton(){

    }

    // 静态内部类
    private static class SingletonHolder {
        // 在内部类中持有外部类的实例，并且可以被直接初始化
        private static final StaticNestedClassSingleton INSTANCE = new StaticNestedClassSingleton();
    }
    /**
     *获取实例的public的静态方法
     */
    public static StaticNestedClassSingleton getInstance(){
        return SingletonHolder.INSTANCE;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

总结

单例模式是一种简单但非常实用的设计模式，在Java开发中有广泛的应用。选择合适的实现方式，可以在保证性能的同时，确保程序运行的正确性。然而，任何设计模式都不是万能的，使用单例模式时也应该考虑其适用场景和潜在的缺点。