一次搞定单例模式

单例模式大家都不陌生、但是写出一个让人满意的单例并不是那么容易的。
从另一个角度来分析单例模式方便大家理解。

单例模式：只能创建出类的一个对象也是唯一的一个对象。
怎么保障只能创建出一个类对象呢？
首先想到的是静态静态对象是属于类的。所以能保证静态对象的唯一。
其次屏蔽类自身具有的构造方法。这样就能屏蔽这种创建类对象的方式。
       类名对象名 = new 类名()

第一：屏蔽构造方法，设置成private的。下面是外部类使用构造方法创建对象的报错信息
SingletonX singletonTest = new SingletonX();
【The constructor SingletonX() is not visible】
第二：自己内部new出一个自己的对象唯一的对象返回。

=============================下面是V1.0版本================================
public class SingletonX {
//私有化的构造方法，保证外部的类不能通过构造器来实例化
private SingletonX() {}
//单例   实例变量
private static SingletonX singleton = null;
//获取单例对象实例   对外提供
public static SingletonX getInstance(){
if(singleton==null)
singleton = new SingletonX();
                                  return singleton;
}
}

=============================下面是V2.0版本================================
上面的代码在多线程的环境中不是线程安全的。
等当两个线程进入if (instance == null)时，两个线程都判断instance为空，接下来就会得到两个实例了。这不是我们想要的单例。
为了保证线程安全。使用synchronized 修饰一下
public static synchronized SingletonX getInstance(){
}

此方法是可以解决问题。但是仔细想一想其实只需要在第一次调用getInstance()的时候加锁就可以了。这样把synchronized 加在方法上会导致每次调用getInstance方法。
把synchronized 加到代码块上试一试吧
=============================下面是V2.5版本================================
//获取单例对象实例   对外提供
public static SingletonX getInstance() {
         if (instance == null) {
             synchronized (Singleton.class) {
             //再次判断是否为空防止上面多线程的时候有多个线程进入了等待synchronized 如不再次进行为空判断依然会出现多个实例。
                 if (instance == null) {
                     instance = new Singleton();
                }
             }
         }
         return singleton;

=============================下面是V2.5版本================================
不过又听说java平台内存模型中有一个叫“无序写”（out-of-order writes）的机制。

instance = new Singleton(); 这行其实做了两个事情：
1、调用构造方法，创建了一个实例。
2、把这个实例赋值给instance这个实例变量。可问题就是，这两步jvm是不保证顺序的。也就是说。可能在调用构造方法之前，instance已经被设置为非空了。
synchronized 能保障同一时间只有一个线程进入同步块。但是不能保证每次都能完整执行同步块，也就是执行了一部分就退出，让给其他线程来执行。 A线程执行了上面说的第2步退出
此时instance 不为空了，我也不知道它现在是一个什么值？ B线程进来判断不为空返回了一个没有调用构造方法实例出来的一个值。紧接着A线程继续调用构造方法返回真正的单例对象。

解决方案：
就是要保障instance = new Singleton() 这个搞成原子性的。引入一个Temp变量来保存创建出来的实例对象，如果没有完整创建，退出。B线程进来instance 依然是Null。

//获取单例对象实例
public static Singleton getInstance() {
     if (instance == null) {
         synchronized (Singleton.class) {          //1
             Singleton temp = instance;            //2
             if (temp == null) {
                 synchronized (Singleton.class) { //3
                     temp = new Singleton();   //4
                 }
                 instance = temp;                  //5
             }
         }
     }
     System.out.println("我是解决无序写懒汉式单例！");
     return instance;
}

=============================下面是V3.0版本================================

虽然实现了但是很乱，精简一下代码换个思路。
//饿汉式
public class Singleton {
      //单例变量 ,static的，在类加载时进行初始化一次，保证线程安全
      private static Singleton instance = new Singleton();

      //私有化的构造方法，保证外部的类不能通过构造器来实例化。
      private Singleton() {}

      //获取单例对象实例
      public static Singleton getInstance() {
          System.out.println("我是饿汉式单例！");
          return instance;
      }
}

代码分析：饿汉式单例，意思就是预先声明Singleton对象，这样带来的一个缺点就是：如果构造的单例很大，构造完又迟迟不使用，会导致资源浪费。

==========继续改进调用getInstance方法时再进行构造方法初始化对V4.0===========
//内部类实现懒汉式
public class Singleton {
      private static class SingletonHolder{
          //单例变量
          private static Singleton instance = new Singleton();
      }

      //私有化的构造方法，保证外部的类不能通过构造器来实例化。
      private Singleton() {}
      //获取单例对象实例
      public static Singleton getInstance() {
          System.out.println("我是内部类单例！");
          return SingletonHolder.instance;
      }
}

懒汉式（避免上面的资源浪费）、线程安全、代码简单。因为java机制规定，
内部类SingletonHolder只有在getInstance()方法第一次调用的时候才会被加载（实现了lazy），
而且其加载过程是线程安全的（实现线程安全）。内部类加载的时候实例化一次instance

SingletonHolder是私有静态内部类，所以不会被其他类知道，同样，static语义也要求不会有多个实例存在。并且，JSL规范定义，类的构造必须是原子性的，非并发的，因此不需要加同步块。同样，由于这个构造是并发的，所以getInstance()也并不需要加同步。

欢迎探讨：QQ 350355139 设计模式一次搞定

参考资料：
http://blog.163.com/yanjingyu_happy/blog/static/111639566201364115047132/

http://devbean.blog.51cto.com/448512/203501/

一次搞定 单例模式

猜你喜欢

一次搞定单例模式