聊聊设计模式的单例模式

单例模式介绍

定义：一个类只有一个实例对象，提供一个供系统全局调用的入口。
说明：对于一些需要保持一致的或者创建实例很耗资源的类，提供一个单例对象，避免系统占用过多内存。单例模式是结构比较简单的模式，但是深入来看却非常复杂的模式。

单例模式的结构

• 构造函数私有化
• 类内部实例化一个对象
• 提供一个public方法访问同一个实例对象

单例实现

根据实例的创建时间，分为饿汉模式和懒汉模式

• 饿汉模式的单例实现

  该模式是线程安全的，因为静态变量在类加载时候就已经被初始化了。

public class EagerSingleton {
    private static final EagerSingleton bean = new EagerSingleton();
    
    private EagerSingleton() {}
    
    public static EagerSingleton getInstance() {
        return bean;
    }
}

• 懒汉模式的单例实现
  懒汉模式跟上述代码结构差不多，只不过静态变量是在调用的时候才进行创建。

public class LazySingleton {
    private static LazySingleton bean;

    private LazySingleton() {}

    public static LazySingleton getInstance() {
        if (bean == null) {
            bean = new LazySingleton();
        }
        return bean;
    }
}

getInsatnce方法里面，会判断bean是否为空，如果为空则会创建该对象，那么如果是在多线程的调用环境中，如果某个线程在执行bean = new LazySingleton()代码时,刚好有其他线程在调用getInstance方法，并且此时前一个前程的bean还没创建成功,则该线程也会再一次执行创建操作,所以可以看出这个这种实现是线程不安全的。

我们用一个场景类来验证一下。

    public static void main(String[] args) {
        ExecutorService executors = Executors.newFixedThreadPool(100);
        for (int i = 0; i < 100; i++) {
            executors.execute(() -> {
                LazySingleton instance = LazySingleton.getInstance();
                System.out.println("获取到的实例对象为：" + instance);
            });
        }
        executors.shutdown();
    }

输出如下：发现第一个和第二个实例不是指向同一个地址的，可以验证多线程环境下会有问题。当然这里是经过多次运行才得到的结果，实际不一定每次都有问题。

获取到的实例对象为：pattern.LazySingleton@3f2d920f
获取到的实例对象为：pattern.LazySingleton@222ee9a2
获取到的实例对象为：pattern.LazySingleton@222ee9a2
获取到的实例对象为：pattern.LazySingleton@222ee9a2
获取到的实例对象为：pattern.LazySingleton@222ee9a2
获取到的实例对象为：pattern.LazySingleton@222ee9a2
获取到的实例对象为：pattern.LazySingleton@222ee9a2
...

优化方法

针对上述问题，可以通过使用饿汉模式来实现，或者通过加锁来保证多线程的运行问题。

public class LazySingleton {
    private static LazySingleton bean;

    private LazySingleton() { }

    public static synchronized LazySingleton getInstance() {
        if (bean == null) {
            bean = new LazySingleton();
        }
        return bean;
    }
}

这里进行了加锁机制，确保了线程安全问题，但是这里会有一定的性能损耗，每次线程都需要等待锁释放后才能调用该方法。实际上这里只要确保对象被创建时只有一个线程成功调用，而一旦对象呗创建成功后，这里就不需要进行加锁机制了。所以这里可以选择在方法内部进行加锁，在条件判断里面。

public class LazySingleton {
    private static LazySingleton bean;

    private LazySingleton() { }

    public static LazySingleton getInstance() {
        if (bean == null) {
            synchronized (LazySingleton.class) {
                if (bean == null) {
                    bean = new LazySingleton();
                }
            }
        }
        return bean;
    }
}