设计模式 - 单例模式 (1/23)

单例模式

饿汉式 (静态常量)

优点：写法简单，在类装载时就完成了实例化，避免了线程同步问题

缺点：在类装载时就完成了实例化，有可能从始至终都用不上这个实例，造成内存浪费

public class Single {
    private Single() {}

    private final static Single single = new Single();

    public static Single getInstance() {
        return single;
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(Single.getInstance() == Single.getInstance());
    }
}

console

true

饿汉式 (静态代码块)

这种方式实际与静态常量方式类似，都是在类加载时实例化。优缺点也与静态常量方式相同

public class Single2 {
    static {
        single = new Single2();
    }

    private Single2() {}

    private final static Single2 single;

    public static Single2 getInstance() {
        return single;
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(Single.getInstance() == Single.getInstance());
        System.out.println(Single2.getInstance() == Single2.getInstance());
    }
}

console

true
true

懒汉式

有可能会出现多个线程同时抢到了 getInstance 方法的情况，所以线程不安全，慎用

可以通过添加 synchronized 来添加线程锁使线程同步，但是会造成线程拥堵。导致效率变低

public class Single3 {
    private Single3() {}

    private static Single3 single = null;

    public static Single3 getInstance() {
        if (null == single) single = new Single3();
        return single;
    }
    
//    public static synchronized Single3 getInstance() {
//        if (null == single) single = new Single3();
//        return single;
//    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(Single.getInstance() == Single.getInstance());
        System.out.println(Single2.getInstance() == Single2.getInstance());
        System.out.println(Single3.getInstance() == Single3.getInstance());
    }
}

console

true
true
true

懒汉式（二）

通过双重验证，再加上 volatile 关键字对变量的修饰达到懒加载/安全并且速度快的单例结果

volatile 详解

public class Single4 {
    private Single4() {}

//    private static Single4 single1 = null;

    /**
     * 添加 volatile 关键字
     * 1、volatile保证可见性
     * 2、volatile不保证原子性
     * 3、volatile禁止指令重排
     */
    private static volatile Single4 single = null;

    /* 反面教材 */
//    public static Single4 getInstance() {
//        if (null == single1) {
//            // 方法没有加锁，无法阻止多线程进入 if 方法
//            synchronized (Single4.class) {
//                single1 = new Single4();
//            }
//        }
//        return single1;
//    }

    /**
     * 通过双重验证，再加上 volatile 关键字对变量的修饰达到懒加载/安全并且速度快的单例结果
     * @return
     */
    public static Single4 getInstance() {
        if (null == single) {
            synchronized (Single4.class) {
                if (null == single) {
                    single = new Single4();
                }
            }
        }
        return single;
    }
}

console

true
true
true
true
true

静态内部类(推荐使用)

线程安全

通过 jvm 虚拟机装载机制来实现单例模式

1. 当外部类在被装载时，内部类不会被装载
2. 当外部类使用到内部类时，才会装载到内部类。jvm 在装载类时线程是安全的。并且静态内部类只会被加载一次

public class Single5 {
    private Single5() {}

    private static class SingleInstance {
        private static final Single5 single = new Single5();
    }

    public static Single5 getInstance() {
        return SingleInstance.single;
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(Single.getInstance() == Single.getInstance());
        System.out.println(Single2.getInstance() == Single2.getInstance());
        System.out.println(Single3.getInstance() == Single3.getInstance());
        System.out.println(Single4.getInstance() == Single4.getInstance());
        System.out.println(Single5.getInstance() == Single5.getInstance());
    }
}

console

true
true
true
true
true

枚举 (推荐使用)

通过枚举实现单例还可以防止被反射进行多次实例化。是目前最完美的单例机制。

public enum Single6 {
    INSTANCE;

    public String method() {
        return "Hello World";
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(Single.getInstance() == Single.getInstance());
        System.out.println(Single2.getInstance() == Single2.getInstance());
        System.out.println(Single3.getInstance() == Single3.getInstance());
        System.out.println(Single4.getInstance() == Single4.getInstance());
        System.out.println(Single5.getInstance() == Single5.getInstance());
        System.out.println(Single6.INSTANCE == Single6.INSTANCE);
        System.out.println(Single6.INSTANCE.method());
    }
}

console

true
true
true
true
true
true
Hello World