这篇文章是今天重写的，开会搞了一下午，另一篇文章写了一半，等晚上写完明天发。最近在使用一个科学的方法研究一个有意思的事，如何科学化的判断你的另一半是否也爱你。废话不多说了，开始一下今天的文章。

单例模式是一种最常见的设计模式，写法也比较多，在这篇文章里面主要是对单例模式的各种写法进行一个介绍。面试的时候会对其中两三种进行体会，而且我还遇到了口述单例模式的例子。重要性就不言而喻了吧。

图片

一、单例模式的介绍

单例模式的重要点在于两个，一个是在哪些地方使用到了单例模式，一个是单例模式如何写。之前只考虑到了如何写，但是哪些地方使用到了，表述的不是很清楚。这一次我找了几个实际例子。

概念：单例模式确保某个类只有一个实例。

有一个通俗的理解，那就是在古代，全国就一个皇帝。如何确保一个皇帝？这就是单例模式。

先看如何写，然后再看在哪用。

二、单例模式的各种写法

1、懒汉式：基本写法

懒汉式就是什么时候用，什么时候创建类的实例。

public class Singleton {
   private Singleton() {}//构造方法
   private static Singleton single=null;

   public static Singleton getInstance() {
        if (single == null) {  
            single = new Singleton();
        }  
       return single;
  }
}

特点：

（1）线程不安全（并发时可能出现多个单例）

（2）构造方法为private，限定了外部只能从getInstance去获取单例

（3）使用static关键字，表明全局只有一份节约了资源，但是如果单例对象比较复杂，new时就比较耗时间。这一点要注意。

上面最主要的缺点就是线程不安全，因此想要解决这个问题，只需要对方法加锁即可。

2、懒汉式：使用synchronized 同步

public class Singleton {  
   private static Singleton instance;  
   private Singleton (){}

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

特点：

（1）此时线程安全

（2）因为加了锁，此时如果单例对象复杂，不仅耗内存，而且new的时间更长，效率更低。

但是上面这种效率不高还有另外一个原因。一个线程过来想要创建单例，首先要进行synchronized锁判断，接下来判断单例是否为空，如果为空，那就创建单例。

既然上面每个线程过来都需要锁判断和单例是否为空的判断，这样做有点耗时，毕竟锁判断是比较耗时的。

3、懒汉式：双重检查锁定

为了解决上面的这个问题，才有了双重检查锁定。

public class Singleton{
private static Singleton instance;  
   private Singleton (){}

public static Singleton getInstance() {
  //第一次检查
   if (singleton == null) {  
     synchronized (Singleton.class) {
        //第二次检查
        if (singleton == null) {  
           singleton = new Singleton();
        }  
    }  
  }  
  return singleton;
}

特点：

（1）线程安全

（2）耗内存，而且单例对象比较复杂，比较耗时，但是对单重锁效率提升不少。

此时为了减少锁的判断量，只需要对单例进行判断即可，如果不为空直接返回，如果为空，那就创建新的单例。

4、饿汉式：基本写法（instance为private）

恶汉式是一开始就先建好，用的时候直接返回即可。

public class Singleton {
   private Singleton() {}
   //提前创建一个Singleton
   private static final Singleton instance = new Singleton();
   //有调用者直接就拿出来给了
   public static Singleton getInstance() {
       return instance;
  }
}

特点：

（1）线程安全（因为提前创建了，所以是天生的线程安全）

（2）单例对象修饰为private，只能通过getInstance获取。

此时单例因为有static修饰，因此在类加载的时候就会初始化，这对应用的启动会造成一定程度的影响。

5、饿汉式：基本写法（instance为public）

public class Singleton {
   public static final Singleton instance = new Singleton();
   private Singleton() {}
}

和上面没什么区别。

6、饿汉式：静态代码块

public class Singleton {
   private Singleton instance = null;
   private Singleton() {}
// 初始化顺序：基静态、子静态 -> 基实例代码块、基构造 -> 子实例代码块、子构造
   static {
       instance = new Singleton();
  }

   public static Singleton getInstance() {
       return this.instance;
  }
}

特点：

（1）线程安全

（2）类初始化时实例化 instance

7、静态内部类

public class Singleton {  
//静态内部类里面创建了一个Singleton单例
   private static class InstanceHolder {  
      private static final Singleton INSTANCE = new Singleton();  
  }  
   private Singleton (){}  
   public static final Singleton getInstance() {  
      return InstanceHolder.INSTANCE;  
  }  
}  

特点：

（1）线程安全

（2）效率高，避免了synchronized带来的性能影响

这种就好很多。很多大佬都推荐。

8、枚举式

public enum Singleton {
   INSTANCE;
   // 枚举同普通类一样，可以有自己的成员变量和方法
   public void getInstance() {
       System.out.println("Do whatever you want");
  }
}

特点：

（1）线程安全（枚举类型默认就是安全的）

（2）避免反序列化破坏单例

枚举类型更好，但是枚举类型会造成更多的内存消耗。枚举会比使用静态变量多消耗两倍的内存，如果是Android应用，尽量避免。原因的话，是因为枚举类型会在编译时转化为一个类，会涉及很多复杂的操作，这里就先不逼逼了。

9、CAS方式

public class Singleton {
  private static final AtomicReference<Singleton> INSTANCE
  = new AtomicReference<Singleton> ();

  private Singleton() {}

  public static Singleton getInstance() {
      for(;;) {
          Singleton instance = INSTANCE.get();
          if(instance != null) {
              return instance;
          }
          instance = new Singleton();
          if(INSTANCE.compareAndSet(null, instance)) {
              return instance;
          }
      }
  }
}

特点：

（1）优点：不需要使用传统的锁机制来保证线程安全，CAS 是一种基于忙等待的算法，依赖底层硬件的实现，相对于锁它没有线程切换和阻塞的额外消耗，可以支持较大的并行度。

如果不理解CAS的话，可以看这篇文章：

java并发编程CAS机制原理分析（面试必问，学习中必会的一个知识点）

（2）缺点：如果忙等待一直执行不成功(一直在死循环中)，会对 CPU 造成较大的执行开销。而且，这种写法如果有多个线程同时执行 singleton = new Singleton(); 也会比较耗费堆内存。

10、Lock机制

// 类似双重校验锁写法
public class Singleton {
      private static Singleton instance = null;
      private static Lock lock = new ReentrantLock();

      private Singleton() {}

      public static Singleton getInstance() {
          if(instance == null) {
              lock.lock(); // 显式调用，手动加锁
              if(instance == null) {
                  instance = new Singleton();
              }
              lock.unlock(); // 显式调用，手动解锁
          }
          return instance;
      }
}

当然还有一些其他的实现单例的写法，比如说登记式单例等等。

三、单例模式的使用

  1.Windows的Task Manager（任务管理器）就是很典型的单例模式（这个很熟悉吧），想想看，是不是呢，你能打开两个windows task manager吗？不信你自己试试看哦~

  1. windows的Recycle Bin（回收站）也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。

  2. 网站的计数器，一般也是采用单例模式实现，否则难以同步。

  3. 应用程序的日志应用，一般都何用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。

  4. Web应用的配置对象的读取，一般也应用单例模式，这个是由于配置文件是共享的资源。

   6.数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。数据库软件系统中使用数据库连接池，主要是节省打开或者关闭数据库连接所引起的效率损耗，这种效率上的损耗还是非常昂贵的，因为何用单例模式来维护，就可以大大降低这种损耗。

  1. 多线程的线程池的设计一般也是采用单例模式，这是由于线程池要方便对池中的线程进行控制。

  2. 操作系统的文件系统，也是大的单例模式实现的具体例子，一个操作系统只能有一个文件系统。

以上内容来源于简书：

https://www.jianshu.com/p/137e65eb38ce

四、总结

图片


有两种场景可能导致非单例的情况

场景一：如果单例由不同的类加载器加载，那便有可能存在多个单例类的实例

场景二：如果 Singleton 实现了 java.io.Serializable 接口，那么这个类的实例就可能被序列化和反序列化。

单例的写法基本上就是这些，可能在不同的场景下使用不同的方式，对我来说，在后端更经常使用的就是枚举类型，但是Android开发当中很少使用。


更多相关文章

  1. Redis为什么又引入了多线程？作者也逃不过“真香定理”？
  2. 详解第三种创建线程的方式-Callable接口
  3. java线程相关面试题（第一版）
  4. Java线程之线程的调度-让步
  5. binlog有哪些工作模式？Linux云计算运维入门
  6. Web开发模式【Mode I 和Mode II的介绍、应用案例】
  7. java中的几个线程池的使用
  8. 《JAVA与模式》之观察者模式

随机推荐

  1. XML中处理指令的代码详解
  2. 详细介绍XML Web Service图文代码实例
  3. 详细介绍XML代码编写的编码与验证问题
  4. XSLT语法—在.net中使用XSLT转换xml文档
  5. XML中的DTD文档类型定义详细介绍
  6. XmlSerializer 对象的Xml序列化和反序列
  7. XML编程中的模式定义XSD示例代码详解
  8. XML中的树形结构与DOM文档对象模型的示例
  9. XPath语法： 在C#中使用XPath示例的具体代
  10. 详解通过XmlDocument读写Xml文档的示例代