设计模式-单例类

单例（Singleton）模式的定义

指一个类只有一个实例，且该类能自行创建这个实例的一种模式。例如，Windows 中只能打开一个任务管理器，这样可以避免因打开多个任务管理器窗口而造成内存资源的浪费，或出现各个窗口显示内容的不一致等错误。

在计算机系统中，还有 Windows 的回收站、操作系统中的文件系统、多线程中的线程池、显卡的驱动程序对象、打印机的后台处理服务、应用程序的日志对象、数据库的连接池、网站的计数器、Web 应用的配置对象、应用程序中的对话框、系统中的缓存等常常被设计成单例。

单例模式有 3 个特点：

单例类只有一个实例对象；
该单例对象必须由单例类自行创建；
单例类对外提供一个访问该单例的全局访问点；

其结构如图 1 所示。

结构图

懒汉模式

public class LazySingleton implements Singleton{

    private static volatile LazySingleton instance=null;    //保证 instance 在所有线程中同步
    
    //private 避免类在外部被实例化
    private LazySingleton(){
        show("懒汉创建");
    }    
    
    public static synchronized LazySingleton getInstance()
    {
        //getInstance 方法前加同步
        if(instance==null)
        {
            instance=new LazySingleton();
        }
        return instance;
    }
    public void show(String message) {
        System.out.print(message+"\n");
    }
}

大家看到volatile,synchronized这种修饰词时，大概就想到有关线程的问题了，没错假如我们不加这两个会如何呢，废话不多说，直接敲代码。

public void init() {
  ExecutorService threadpool = Executors.newFixedThreadPool(20);
  for (int i = 0; i < 20; i++) 
  {
        threadpool.execute(new Runnable() {
                public void run() {
          System.out.println(Thread.currentThread().getName() + ":" + LazySingleton.getInstance());
          }
      });
   }
}

懒汉创建
懒汉创建
懒汉创建
pool-1-thread-18:org.design.singleton.mode.LazySingleton@2e509126
懒汉创建
pool-1-thread-17:org.design.singleton.mode.LazySingleton@7153e174
懒汉创建
pool-1-thread-15:org.design.singleton.mode.LazySingleton@6714c37e
pool-1-thread-16:org.design.singleton.mode.LazySingleton@6714c37e
pool-1-thread-20:org.design.singleton.mode.LazySingleton@24c394d2
......

结果就有点扯淡了,完全不符合要求。足以看见其线程安全问题。所以尽管需要消耗些性能但这是必须的。但我们来看看饿汉模式。

饿汉式单例

该模式的特点是类一旦加载就创建一个单例，保证在调用 getInstance 方法之前单例已经存在了。好比如房子建好了，但是还没装修我就入住了。不过饿汉式单例在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以是线程安全的，可以直接用于多线程而不会出现问题。

public class HungrySingleton implements Singleton{
   private static final HungrySingleton instance=new HungrySingleton();
    
    private HungrySingleton(){
        System.out.print("饿汉创建\n");
    }
    
    public static HungrySingleton getInstance()
    {
        return instance;
    }
    
    public void show(String message) {
        System.out.print(message+"\n") ;
    }
}

然后有点很不好的是，我还没用你，你就自己创建了，这对于程序来说一两个没啥问题，但是万一多呢？这就很耗费资源。我们更希望是用到才创建。有没有这种单例类呢？答案绝对是有的。来看看下面这个例子。

public class StaticSingleton implements Singleton{
    
    private Integer age=20;
    
    private static class InnerSingleton{
        private static StaticSingleton instance=new StaticSingleton();
    }
    
    public StaticSingleton() {
        show("内部静态创建");
    }
    
    public static StaticSingleton getInstance() {
        return InnerSingleton.instance;
    }

    @Override
    public void show(String message) {
        System.out.print(message+"\n");
    }

}

这就做到我们用到才创建，而且不存在线程安全问题。比较符合我们的预期。

单例模式的应用场景

前面分析了单例模式的结构与特点，以下是它通常适用的场景的特点。
在应用场景中，某类只要求生成一个对象的时候，如一个班中的班长、每个人的身份证号等。
当对象需要被共享的场合。由于单例模式只允许创建一个对象，共享该对象可以节省内存，并加快对象访问速度。如 Web 中的配置对象、数据库的连接池等。
当某类需要频繁实例化，而创建的对象又频繁被销毁的时候，如多线程的线程池、网络连接池等。