• 目录
  • 一.什么是单例？
  • 二.有几种？
  • 三.应用场景
  • 四.注意的地方

一.什么是单例？

单例模式 保证一个类在内存中只有一个实例（对象），并提供一个访问它的全局访问点。

通常我们可以让一个全局变量使得一个对象被访问，但它不能防止你实例化多个对象。一个最好的办法就是，让类自身负责保存它的唯一实例。这个类可以保证没有其他实例可以被创建，并且它可以提供一个访问该实例的方法 —— 大话设计模式--第21章

单例Boy.jpg

二.单例有几种？

具体区分为下面几种：

• 饿汉式
• 懒（饱）汉式
  • 线程不安全（单线程下操作的）
  • 线程安全
    • 方法加锁式
    • 双重判断加锁式DCL（Double-Check Locking）--- 方法加锁式加强版
• 静态嵌套类式(推荐使用)
• 枚举式(推荐使用)
• 使用容器单例

不和你多bb ，上代码

b.jpg

1.饿汉式

public class Signleton{
    //对于一个final变量。  
    // 如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；  
    // 如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。
   private final static Signleton instance = new Signleton();
   
   private Signleton(){
       
   }
   
   public static  Signleton getInstance(){
        return instance;
   }
}

解释： 拿时间换空间，因为实例对象在类加载过程中就会被创建，在getInstance()方法中只是直接返回对象引用。因为这种创建实例对象方式比较‘急’，所以称为饿汉式。

优点：快很准，无需关心线程安全问题。

缺点：
  1.无论对象会不会被使用，在类加载的时候就创建对象了，这样会降低内存的使用率。
   2.如果在一个大环境下使用了过多的饿汉单例，则会生产出过多的实例对象，无论你是否要使用他们

饿.jpg

2.懒（饱）汉式

(1)线程不安全（单线程下操作的）

public class Signleton{
  private static Signleton instance = null;
  
  private Signleton(){
  
  }
  
  public static Signleton getInstance(){
     if(instance==null){
        instance = new Signleton();
     }
     return instance;
  }
}

解释： Singleton的静态属性instance中，只有instance为null的时候才创建一个实例，构造函数私有，确保每次都只创建一个，避免重复创建。之所以被称为“懒汉”，因为它很懒，不急着生产实例，在需要的时候才会生产。

优点：延迟加载

缺点：只在单线程的情况下正常运行，在多线程的情况下，就会出问题。例如：当两个线程同时运行到判断instance是否为空的if语句，并且instance确实没有创建好时，那么两个线程都会创建一个实例。

(2)线程安全

方法加锁式

public class Signleton{
  private static Signleton instance = null;
  
  private Signleton(){
  
  }
  //给方法加锁 若有ABCD线程使用 A线程先进入 BCD线程都需要等待A线程执行完毕释放锁才能获得锁执行该方法
  //这样效率较低 
  public syschronized static Signleton getInstance(){
     if(instance==null){
        instance = new Signleton();
     }
     return instance;
  }
}

解释：给方法添加[synchronized],使之成为同步函数。两个线程同时想创建实例，由于在一个时刻只有一个线程能得到同步锁，当第一个线程加上锁以后，第二个线程只能等待。第一个线程发现实例没有创建，创建之。第一个线程释放同步锁，第二个线程才可以加上同步锁，执行下面的代码。由于第一个线程已经创建了实例，所以第二个线程不需要创建实例。保证在多线程的环境下也只有一个实例。

优点： 保证了线程安全。延时加载，用的时候才会生产对象。

缺点： 需要保证同步，付出效率的代价。加锁是很耗时的。。。

双重判断加锁式DCL

public class Signleton {
  private static Signleton instance = null;
  
  private Signleton(){
  
  }

  //假设有ABCD 个线程 使用这个方法
  public static Signleton getInstance(){
  //BCD都进入了这个方法
    if(instance==null){
      //而A线程已经给第二个的判断加锁了 
      syschronized(Signleton.class){
         //这时A挂起,对象instance还没创建 ，故BCD都进入了第一个判断里面，并排队等待A释放锁
         //A唤醒继续执行并创建了instance对象，执行完毕释放锁。
         //此时到B线程进入到第二个判断并加锁，但由于B进入第二个判断时instance 不为null了  故需要再判断多一次  不然会再创建一次实例
          if(instance==null){
             instance = new Signleton();
          }
       
      } 
    }
    return instance;
   }
}

解释：方法加锁式的优化。只有当instance为null时，需要获取同步锁，创建一次实例。当实例被创建，则无需试图加锁。。

优点： 保证了线程安全。延时加载，用的时候才会生产对象。进行双重判断，当已经创建过实例对象后就无需加锁，提高效率。

缺点： 编写复杂、难记忆。虽然是优化加锁式，但加锁始终会耗时。

3.静态嵌套类式(推荐使用)

public class Signleton{
   private Signleton{
   }
  
   //静态嵌套类  这里给个链接 区分静态嵌套类和内部类[静态嵌套类和内部类](http://blog.csdn.net/iispring/article/details/46490319)
   private static class  SignletonHolder{
      public static final Signleton instance = new Signleton();
  }
  
  public static Signleton getInstance(){
   return SignletonHolder.instance;
ins't
  }
  
}

解释： 定义一个私有的静态嵌套类，在第一次用这个嵌套类时，会创建一个实例。而类型为SingletonHolder的类，只有在Singleton.getInstance()中调用，由于私有的属性，他人无法使用SingleHolder，不调用Singleton.getInstance()就不会创建实例。

优点： 保证了线程安全。无需加锁，延迟加载，第一次调用Singleton.getInstance才创建实例。推荐使用。

缺点： 无。

4.枚举式(推荐使用)

为了方便理解枚举式 这边简单介绍一下枚举(在jdk1.5后)

//枚举Type
public enum Type{
   A,B,C;
  private String type;
  Type(type){
     this.type = type;
 }
 public String getType(){
    return type;
  }
}
//可认为等于下面的
public class Type{
  public static final Type A=new Type(A);
  public static final Type B=new Type(B);
  public static final Type C=new Type(C);
ins't
}

所以Type.A.getType()为A.
推荐去了解一下
Java学习整理系列之Java枚举类型的使用
Java学习整理系列之Java枚举类型的原理

好了 开始介绍枚举式了 看代码

public class Signleton{

public static Signleton getInstance(){
   return SignletonEnum.INSTANCE.getInstance();
}

public enum SignletonEnum{
   INSTANCE;
   
   private Signleton instance;
   
   //由于JVM只会初始化一次枚举实例，所以instance无需加static 
   private SignletonEnum(){
        instance = new Signleton();
   }
   
   public getInstance(){
       return instance;   
   }
}

}

解释： 定义内部的枚举，由于类加载时JVM只会初始化一次枚举实例，所以在构造函数中创建Signgleton对象并保证了这个对象实例唯一。
通过调用枚举INSTANCE方法getInstance （SignletonEnum.INSTANCE.getInstance()）获取实例对象。

优点： 枚举提供了序列化机制--例如在我们要通过网络传输一个数据库连接的句柄，会提供很多帮助。

单元素的枚举类型已经成为实现Singleton的最佳方法。Effective Java

5.使用容器单例

public class Singleton { 
   //用Map保存该单例
    private static Map<String, Object> objMap = new HashMap<>(); 

    private Singleton() { 

    } 

    public static void putObject(String key, String instance){ 
        if(!objMap.containsKey(key)){ 
            objMap.put(key, instance); 
        } 
    } 

    public static Object getObject(String key){ 
        return objMap.get(key); 
    } 
}

解释： 在程序开始的时候将单例类型注入到一个容器之中 ,在使用的时候再根据 key 值获取对应的实例,这种方式可以使我们很方便的管理很多单例对象,也对用户隐藏了具体实现类,降低了耦合度。

缺点： 会造成内存泄漏。（所以我们一般在生命周期销毁的时候也要去销毁它） 。

三.应用场景

一般创建一个对象需要消耗过多的资源,如:访问I0和数据库等资源或者有很多个地方都用到了这个实例。

四.注意的地方

双重判断加锁式DCL ：这种写法也并不是保证完全100%的可靠,由于 java 编译器允许执行无序,并且 jdk1.5之前的jvm ( java 内存模型)中的 Cache,寄存器到主内存的回写顺序规定,第二个和第三个执行是无法保证按顺序执行的,也就是说有可能1-2-3也有可能是1-3-2; 这时假如有 A 和 B 两条线程, A线程执行到3的步骤,但是未执行2,这时候 B 线程来了抢了权限,直接取走 instance 这时候就有可能报错。

简单总结就是说jdk1.5之前会造成两个问题:

1、线程间共享变量不可见性;

2、无序性(执行顺序无法保证);

当然这个bug已经修复了,SUN官方调整了JVM,具体了Volatile关键字,因此在jdk1.5之前只需要写成这样既可, private Volatitle static Singleton instance; 这样就可以保证每次都是从主内存中取,当然这样写或多或少的回影响性能,但是为了安全起见,这点性能牺牲还是值得。