Java设计模式（1）—

Java设计模式（1）——单例模式

news/2025/2/19 8:02:30

一、单例模式

单例模式是Java设计模式中最简单的设计默认之一，其主要作用是用于维护全局单一示例对象。

可以防止资源竞争
用于维护全局单一对象，防止反复初始化。如配置、连接等。

设计关键点：

构造函数private，保证只能通过类静态方法获取实例
实例是静态对象，保证只被创建一次，线程安全

饿汉式

java">public class SingletonHungry {

    private static SingletonHungry INSTANCE = new SingletonHungry();

    private SingletonHungry() {

    }

    public static SingletonHungry getInstance() {
        return INSTANCE;
    }
}

类加载时就INSTANCE对象被初始化，无法延迟初始化
通过反射调用时会多次创建INSTANCE对象，

懒汉式

java">public class SingletonLazy {

    private static SingletonLazy instance;

    private SingletonLazy() {

    }

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

在getInstance时再对INSTANCE初始化，实现了懒加载。
加锁保证线程安全，但是每次调用都需要加锁，性能低。

多重检测

java">public class SingletonDcl {
    private volatile static SingletonDcl instance; // 1

    private SingletonDcl () {

    }

    public static SingletonDcl getInstance() {
        if (instance == null) { // 2
            synchronized (SingletonDcl.class) { //3
                if (instance == null) { //4
                    instance = new SingletonDcl();
                }
            }
        }
        return instance;
    }
}

1中的volatile关键字保证对象在new出来，并赋值给instance之后还没被初始化（执行构造函数），就被另一个对象使用（因为对象new操作和初始化操作不是原子操作）。不过只有很低很低的版本java才存在这个问题，现在jdk对象new操作和初始化操作已经被设计为原子操作。
2的第一层判空保证在对象被new出来后，不再进入加锁逻辑，解决懒汉式性能低问题
3锁定要锁定类对象，保证全局唯一性
4的第二层判空为了解决如下问题：假设有两个线程A和B，都进行完第一次判空了，A和B都阻塞在synchronized位置，则A获得锁后new出对象释放锁，B再次获得锁后，需要判断A是否已经new过对象，否则就不能保证对象唯一。
双重检查锁的这种单例模式性能比较高

静态内部类

java">public class SingletonInternal {

    private SingletonInternal() {

    }

    private static class SingletonHolder {
        private static final SingletonInternal INSTANCE = new SingletonInternal();
    }

    public static SingletonInternal getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

SingletonInternal的加载不会初始化INSTANCE，这时与饿汉式的区别。只有通过显式调用 getInstance 方法时，才会显式装载 SingletonHolder 类，从而实例化 INSTANCE，实现了懒加载。

枚举

java">public enum Singleton {

    INSTANCE;

    public void doSomething() {
        System.out.println("doSomething");
    }

}
调用方法：

public class Main {

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

}