java 设计模式之单例模式

• 相信很多做java的童鞋都听说过.但是一下子让他们写出来.即便是2-3年工作经验的人,也不一定能写出来一个可用的单例模式.所以我们今天来学习学习单例模式

• 通常有俩种模式

• 立即加载-饿汉模式: 立即加载就是使用的时候对象已经实例化

  public class MyObject(){
  private static MyObject = new MyObject();
  …………………….
  }

  • 延时加载-懒汉模式 就是调用get()方法时,对象才被实例

单例模式:

public class SimpleSingle {    /*持有 私有 静态 实例 防止被应用      * -延时加载懒汉模式 就是对象调用时 对象还没有创建      * 立即加载-饿汉模式  = new object()     *      * */    private static SimpleSingle instance = null;    /* 私有构造方法 防止被实例化 */    private SimpleSingle() {    }    /**     * 这里没有同步代码块.所以是线程不安全的     * @return     */    public static SimpleSingle getIntance(){        if(instance == null){            instance = new SimpleSingle();        }        return instance;    }    /**如果该对象用于序列化 可保持 序列化前后一致**/    public Object readResolve(){        return instance;    }    /**     * 线程安全的      * 如果是将synchronized 加到方法上 就是锁了这个对象,效率低下 ,因为只需要在第一次创建的时候加锁 之后就不需要了     *      */     public static synchronized SimpleSingle getInstance1(){         if(instance == null){             instance = new SimpleSingle();         }         return instance;     }    /**     * 使用同步代码块   创建 单例对象     * @return     */    public static SimpleSingle getInstance3(){        if(instance == null){            synchronized (SimpleSingle.class) {                if(instance == null){                instance =  new SimpleSingle();                }            }        }        return instance;    }}

getIntance3() 方法看似没有什么问题
将 synchronized 关键字加在了内部，也就是说当调用的时候是不需要加
锁的，只有在 instance 为 null，并创建对象的时候才需要加锁，性能有一定的提升。但是，这样的情况，
还是有可能有问题的，看下面的情况：在 Java 指令中创建对象和赋值操作是分开进行的，也就是说
instance = new Singleton();语句是分两步执行的。但是 JVM 并不保证这两个操作的先后顺序，也就是
说有可能 JVM 会为新的 Singleton 实例分配空间，然后直接赋值给 instance 成员，然后再去初始化这
个 Singleton 实例。这样就可能出错了，我们以 A、 B 两个线程为例：
a>A、 B 线程同时进入了第一个 if 判断
b>A 首先进入 synchronized 块，由于 instance 为 null，所以它执行 instance = new Singleton();
c>由于 JVM 内部的优化机制， JVM 先画出了一些分配给 Singleton 实例的空白内存，并赋值给 instance
成员（注意此时 JVM 没有开始初始化这个实例），然后 A 离开了 synchronized 块。d>B 进入 synchronized 块，由于 instance 此时不是 null，因此它马上离开了 synchronized 块并将结果
返回给调用该方法的程序。
e>此时 B 线程打算使用 Singleton 实例，却发现它没有被初始化，于是错误发生了。

---

实际情况是，单例模式使用内部类来维护单例的实现， JVM 内部的机制能够保证当一个类被加载的时
候，这个类的加载过程是线程互斥的。这样当我们第一次调用 getInstance 的时候， JVM 能够帮我们保
证 instance 只被创建一次，并且会保证把赋值给 instance 的内存初始化完毕，这样我们就不用担心上
面的问题。同时该方法也只会在第一次调用的时候使用互斥机制，这样就解决了低性能问题。这样我们
暂时总结一个完美的单例模式：

public class Singleton { /* 私有构造方法，防止被实例化 */ private Singleton() { } /* 此处使用一个内部类来维护单例 */ private static class SingletonFactory { private static Singleton instance = new Singleton(); } /* 获取实例 */ public static Singleton getInstance() { return SingletonFactory.instance; } /* 如果该对象被用于序列化，可以保证对象在序列化前后保持一致 */ public Object readResolve() { return getInstance(); } }

世面上有很多很多的单例模式..但是我还是喜欢自己写的这个双重检测的单例模式 double -check -locking
使用dcl 双重检测来实现单例模式.

/** * 鉴于之前写的多线程单例模式有问题. * 这次我写一个dcl 双重检查 单例模式 * ---doble chek locking */public class MyObject {    //静态实例防止被实例    private volatile static MyObject myObject;    private MyObject() {    }    /**     * 使用双检测机制来解决问题..既不需要同步代码的异步性.     * 也可以保持单例.     * @return     */    public static  MyObject getInstance(){        try {            if (myObject != null) {            }else{//              Thread.sleep(3000);                synchronized (MyObject.class) {                    if(myObject == null){                        myObject = new MyObject();                    }                }            }        } catch (Exception e) {            // TODO Auto-generated catch block            e.printStackTrace();        }        return myObject;    }}