单例模式几种写法

所谓单例模式，简单来说，就是在整个应用中保证只有一个类的实例存在。类似Spring中的IOC 配置，bean实例化默认都是单例模式的。

 单例的四种写法：

1.饿汉式单例

//饿汉式
public class Singleton{
  //1.私有的唯一的静态实例变量,在类加载的时候就创建好单例对象  
  private static final Singletion instance= new Singleton();
  //2.私有的构造函数,确保不能在类的外部访问该类的构造函数  
  private Singleton{}
  //3.通过静态工厂方法返回类的唯一实例
  private static Singletion getInstance(){
    return instance;
  }
}

  优点：此写法是线程安全的

  缺点：会增大初始化类和创建对象的开销

 

2.懒汉式

public class Singleton {
  //1.一个私有的指向自己的静态变量  
　private static Singleton instance = null;
  // 2.私有的构造方法,保证不能从外部创建对象
  private Singleton{}
  //3.真正获取实例的时候才进行初始化，如果多线程访问 synchronized会阻塞其他线程
　public static synchronized Singleton getInstance() {
　　if (instance == null)
　　　instance = new Singleton(); // lazy load
　　return instance;
　} 
}

优点： 延时加载，只有在使用的时候进行初始化

问题：同步锁粒度在多线程进行获取实例的时候会出现阻塞，加大了因锁竞争的性能开销

 

3.double-check双重检查锁定

public class Singleton { 
  //1.volatile保证可见性
　private static volatile Singleton instance = null;
  // 2.私有的构造方法,保证不能从外部创建对象
  private Singleton{}
　public static Singleton getInstance() { 
     //3.instance使用volatile标识可以保证所有线程访问同一共享变量的可见性问题
 　　if (instance == null) {// double check (jdk1.5+)
      //4.synchronized虽然保证了原子性，但不能保证 同步方法里面的顺序性
      //5. instance = new Singletion(),其实由三步组成  
      //   1).分配对象内存空间 2).初始化对象  3).设置instance指向刚分配的内存地址 
      //6.由于不同cpu的内核，JMM重排序粒度不一样，instance在第2，3步见可能会被重排序
      //  执行过程中instance不为null,但获取对象 并不是真正赋值对象(旧值或空值)
　　　synchronized (Singleton.class)
　　　　if (instance == null){
　　　　　instance ＝ new Singleton();
        }
      }
　　return instance; 　　
　} 
} 

优点： 用双重验证的方式，降低因多线程因为同步锁而造成的开销,同步锁保证模块执行的原子性，volatile保证实例可见性

缺点：同步锁模块内部方法体instance ＝ new Singleton();并不是原子性操作(像count++也不是原子性操作) 还是可能造成JIT编译器对代码进行重排序 导致对象的值不正确

 

4.静态内部类写法

public class Singleton { 
  //1.在第一次被引用时被加载 
　private static class Holder { // lazy class
　　static final Singleton instance = new Singleton();
　}
  //2.保证不能进行构造
  private Singleton(){ } 
  //3.通过静态方法获取
　public static Singleton getInstance() {
　　return Holder.instance; 　　
　} 
} 

 优点：线程安全的，且在使用时才会被进行初始化操作，优于上面三种方式

 

5.单例  枚举写法

 

public enum SingletonEnum {

    instance;
    /*
     * do something
     */
    public void doSomething(){
        System.out.println("do something");
    }
}

 

 

 

总之，懒汉，恶汉，双重校验锁，静态内部类，枚举。
恶汉：因为加载类的时候就创建实例，所以线程安全(多个ClassLoader存在时例外)。缺点是不能延时加载。
懒汉：需要加锁才能实现多线程同步，但是效率会降低。优点是延时加载。
双重校验锁：麻烦，在当前Java内存模型中不一定都管用，某些平台和编译器甚至是错误的，因为instance = new Singletion()这种代码在不同编译器上的行为和实现方式不可预知。
静态内部类：延迟加载，减少内存开销。因为用到的时候才加载，避免了静态field在单例类加载时即进入到堆内存的permanent代而永远得不到回收的缺点(大多数垃圾回收算法是这样)。
枚举：很好，不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。但是失去了类的一些特性，没有延迟加载，用的人也太少了～～

 

可参考：

http://www.tuicool.com/articles/NVza2am