前言

单例设计模式在设计模式中的定义是：

确保一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。

为了保证内存中只有一个类的对象，我们必须对对象创建加以控制。并能让外部获取对象，我们提供获取本类对象的方法。所以，我们对单例这种类提出如下几个要求：

私有化构造器，将创建本来对象的方法控制在本类中。
提供静态方法供外部获取本类对象。

但满足以上条件的单例模式代码有很多种，较为常见的有如下几种：

饿汉式
懒汉式
Double check模式
InnerClass

以下我们就对这几种模式依次介绍下。

饿汉式

饿汉式的单例是在本类中拥有本类的对象，并且提供了静态方法供外部获取。所以本类中拥有本类对象也必须是静态的。饿汉式主要特点是在类加载时就创建对象：

public class SingletonFirst {

 //本类拥有拥有本类的成员,并且在类一加载的时间就创建
 private static SingletonFirst single=new SingletonFirst();
 //私有化本类的构造器
 public SingletonFirst() {
  super();
 }
 //对外提供获取单例的方法
 public static SingletonFirst getInstance(){
  return single;
 }
}
```
饿汉式的优点
+ 代码简单，明了，

+ 不存在线程安全问题。

缺点：
+ 单例对象生存周期过长，对资源占用比较厉害

##懒汉式
为了解决饿汉式的缺点，我们将对象的创建延后到了外部调用静态方法的时候。代码如下：
```
public class SingletonSecond {

 // 本类拥有拥有本类的成员,并且在类一加载的时间就创建
 private static SingletonFirst single;

 // 私有化本类的构造器
 public SingletonSecond() {
  super();
 }

 // 对外提供获取单例的方法
 public static SingletonFirst getInstance() {
  // 在获取对象时，先行判定有没有。这个对象。有就直接返回
  if (single == null) {
   single = new SingletonFirst();
  }
  return single;
 }
}
```
饿汉式的优点：
+ 在外部类调用方法的时候才创建对象。减少资源的浪费

缺点：
+ 存在线程安全问题。

##Double check模式
double check主要是针对懒汉式的改进。加了同步和双重判定机制。代码如下：
```
public class SingletonDoubleCheck {


 // 内部持有本类成员
 private static SingletonDoubleCheck single;

 // 私有化构造器
 private SingletonDoubleCheck() {
  super();
 }

 // 对外提供获取本类对象的方法
 public static SingletonDoubleCheck getInstance() {
  // 外部的判断，用来消除同步代码块在线程创建以后资源消耗过多的问题
  if (single == null) {
   // 用同步代码块来确保在多线程下懒汉式的线程安全问题
   synchronized (SingletonDoubleCheck.class) {
    // 检测对象是否存在。不存在则创建对象
    if (single == null) {
     single = new SingletonDoubleCheck();
    }
   }
  }
  return single;
 }
}
```
double check模式的优点：
+ 不存在线程安全问题。

+ 保证了单例在需要时加载

缺点：
+ 相对于前面两种模式代码比较难以理解。

InnerClass
利用静态内部类的**随着调用而加载**的特性，在静态内部类中创建本类的静态成员变量。因为静态内部来唯一，而保重外部类对象的唯一性。
```
public class SingletonInner {

 // 私有化构造器
 private SingletonInner() {
  super();
 }

 // 提供静态内部类用于创建单例对象
 private static class InnerClass {
  // 在内部类内部创建外部对象。并且设置为静态以保证在内部类中对象唯一。
  private static SingletonInner single = new SingletonInner();
 }

 // 提供静态方法，对外提供访问接口
 public static SingletonInner getInstance() {
  return InnerClass.single;
 }
}
```
InnerClass方式解决了单例的生存周期和线程安全问题。并且代码也简单明了。
##总结
以上几种叫常见的几种单例模式。懒汉式和饿汉式最容易理解，但使用时都存在一些问题。故我们都不用，我们主要使用下面这两种模式来解决实际工作中的问题。