吃透设计模式之单例模式

吃透设计模式之单例模式

提到单例模式，那可谓是家喻户晓，可以说这个模式是设计模式最常见之一。说到单例模式，那不得不提懒汉式和饿汉式两种方式。相信知道单例模式的人对这两种模式也是比较熟悉的，看到这里你还以为我就是讲讲这两种模式吗？那肯定不是，既然来了，就给你多讲解几种。

那就先从懒汉式和饿汉式开始吧。

饿汉式

package 设计模式.单例模式;

public class 饿汉式 {
    private static final 饿汉式 instance = new 饿汉式();

    private 饿汉式() {}
    
    public static 饿汉式 getInstance() {
        return instance;
    }
    
    public static void main(String[] args) {
        for(int i = 0; i < 100; i++) {
            new Thread(() -> {
                System.out.println(饿汉式.getInstance().hashCode());
            }).start();
        }
    }

}

问题1：问题来了，你知道它为什么叫饿汉式吗？有什么缺点吗？

懒汉式

package 设计模式.单例模式;

public class 懒汉式 {
    private static 懒汉式 instance;

    private 懒汉式() {}

    public static 懒汉式 getInstance() {
        if (instance == null) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            instance = new 懒汉式();
        }
        return instance;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                System.out.println(懒汉式.getInstance().hashCode());
            }).start();
        }
    }
}

问题2：问题又来了，你知道它为什么叫懒汉式吗？有什么缺点吗？

懒汉式优化

package 设计模式.单例模式;

public class 懒汉式优化 {
    private static 懒汉式优化 instance;

    private static final Object lock = new Object();

    public static 懒汉式优化 getInstance() {
        if (instance == null) {
            synchronized (lock) {
                if (instance == null) {
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    instance = new 懒汉式优化();
                }
            }
        }
        return instance;
    }
    public static void main(String[] args) {
        for(int i = 0; i < 100; i++) {
            new Thread(() -> {
                System.out.println(懒汉式优化.getInstance().hashCode());
            }).start();
        }
    }
}

问题3：为什么能优化懒汉式？这里做两次判断instance == null是必须的吗？

单例内部类实现

package 设计模式.单例模式;

public class 单例内部类实现 {
    private static 单例内部类实现 instance;

    private 单例内部类实现() {}

    private static class Inner {
        private static final 单例内部类实现 instance = new 单例内部类实现();
    }

    private static 单例内部类实现 getInstance() {
        return Inner.instance;
    }

    public static void main(String[] args) {
        for(int i = 0; i < 100; i++) {
            new Thread(() -> {
                System.out.println(单例内部类实现.getInstance().hashCode());
            }).start();
        }
    }
}

问题4：为什么用内部类能保证单例？

单例枚举

package 设计模式.单例模式;

public enum 单例枚举 {
    INSTANCE;
    public static void main(String[] args) throws Exception {
        for(int i = 0; i < 100; i++) {
            new Thread(() -> {
                System.out.println(单例枚举.INSTANCE.hashCode());
            }).start();
        }
    }
}

问题5：这种方式与之前的方式对比，有什么优点？

现在来回答上面的问题。

1. 因为在类加载的时候即初始化类实例，缺点就是类加载即实例化，如果类用不到，类在装载的时候没必要实例化；
2. 真正要用的时候才去实例化，虽然这里会判断instance是否为null，但是存在线程不安全的情况；
3. 通过加锁的方式，要实例化之前要加锁，以免其他线程同时实例化。加锁前后两次判断instance是否为空，第一次判断是避免频繁加锁，第二次判断是保证多线程不会多次创建实例；
4. 外部类加载的时候，内部类不会被加载（懒加载），只有在调用getInstance方法的时候才会别实例化。这里利用jvm的一个特性，就是一个类只会加载一次，因此内部类也只会被进行一次实例化，从而保证了单例；
5. 利用枚举的特性，因而只能存在一个实例。非常完美的方式！

到这里，你对单例模式有了个大概了解吧，如果对上面的内容还不理解的，可以拷贝代码运行调试看看结果。后面我们会继续学习其他设计模式。