设计模式---单例模式

       其实模式实现方式的叫法无所谓记住不记住，知道如何实现以及该实现方式的优缺点即可。

• 饿汉模式

public class Singleton{
    private static Singleton singleton = new Singleton ();

    private Singleton(){}

    public static Singleton getInstance(){
        return singletion;
    }
}

public class Singleton{
    private static Singleton singleton;

    static{
        singleton = new Singleton();
    }

    private Singleton(){}

    public static Singleton getInstance(){
        return singletion;
    }
}

       这种实现方式是线程安全的，在类加载的时候便创建唯一的对象。这也是它的缺点，一开始便创建了对象，如果整个系统运行过程中未使用到该对象，则会造成资源浪费和效率问题。

• 懒汉模式

public class Singleton{
    private static Singleton singleton;

    private Singleton(){}

    public static synchronized Singleton getInstance(){
        if(singleton == null){
            singleton = new Singleton();
        }

        return singletion;
    }
}

　　这里使用synchronized关键字对方法进行同步，这也是初学者都会写的一个实现单例的方法。他的优点是只有当使用到这个对象时才会实例化，一定程度上节约了资源。但是每次调用这个方法时，都需要进行同步，造成不必要的开销。
　　此方式并不推荐使用。
　　
- Double CheckLock (DCL)实现

public class Singleton{
    private static Singleton singleton;

    private Singleton(){}

    public static Singleton getInstance(){
        if(singleton == null){
            synchronized(Singleton.class){
                if(singleton == null){
                    singleton = new Singleton();
                }
            }
        }

        return singletion;
    }
}

　　与懒汉模式相比，同步模块是对当前class对象进行同步锁，在进入方法时首先判断对象是否为空，这就避免了每次都要进行同步的代价。
　　该实现方式涉及到一个Java内存模型问题，实例内存的分配与引用的赋值的顺序可能出现错序，导致单例失败。具体可另行百度了解。
　　
- 静态内部类单例模式

public class Singleton{

    private Singleton(){}

    /**
    *  静态内部类
    */
    private static class SingletonHolder{
        private static final Singleton singleton = new Singleton();
    }

    public static Singleton getInstance(){

        return SingletonHolder.singletion;
    }

}

　　静态内部类只有在使用到的时候才会进行加载，且仅加载一次。当getInstance方法第一次被调用的时候，它第一次读取SingletonHolder.singletion，内部类SingletonHolder类得到初始化，而这个类在装载并被初始化的时候，会初始化它的静态域，从而创建Singleton的实例，由于是静态的域，因此只会在虚拟机装载类的时候初始化一次，并由虚拟机来保证它的线程安全性。
　　这种方式即能做到延迟加载，也保证了线程的安全性。
　　
- 枚举单例

public enum Singleton{

    INSTANCE;

    public void doSomething(){
        //TODO
    }

}

　　枚举的用法与类极其类似，字段、方法都拥有，但区别是枚举保证了单例的“绝对性”。下面讲到反序列化时再说。
　　
- 使用容器实现

public class SingletonManager{

    private static Map<String, Object> objMap = new HashMap<>();

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

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

　　将所要用到的单例先注入到统一的管理类中，使用时通过key值从容器中取出即可。

• 序列化对单例的破坏
  　　如果需要实现单例的类实现了Serializable接口，那么假如有这么一段代码：

ObjectOutputStream output = new ObjectOutputStream(new FileOutputStream("..."));
//Singleton.getSingleton()获取单例
output.writeObject(Singleton.getSingleton());

//Read Obj from file
File file = new File("...");
ObjectInputStream input =  new ObjectInputStream(new FileInputStream(file));
Singleton newInstance = (Singleton) input.readObject();

//判断是否是同一个对象
System.out.println(newInstance == Singleton.getSingleton());

　　最终结果输出是 false。这说明通过对Singleton的序列化与反序列化得到的对象是一个新的对象，这就破坏了Singleton的单例性。
　　这里我们主要看一下ObjectInputStream的readOrdinaryObject方法的代码片段：

private Object readOrdinaryObject(boolean unshared)throws IOException{
        //此处省略部分代码

        Object obj;
        try {
            obj = desc.isInstantiable() ? desc.newInstance() : null;
        } catch (Exception ex) {
            throw (IOException) new InvalidClassException(
                desc.forClass().getName(),
                "unable to create instance").initCause(ex);
        }

        //此处省略部分代码

        if (obj != null && handles.lookupException(passHandle) == null 
            && desc.hasReadResolveMethod()){
            Object rep = desc.invokeReadResolve(obj);
            if (unshared && rep.getClass().isArray()) {
                rep = cloneArray(rep);
            }
            if (rep != obj) {
                handles.setObject(passHandle, obj = rep);
            }
        }

        return obj;
}

　　其中：

isInstantiable：如果一个serializable/externalizable的类可以在运行时被实例化，那么该方法就返回true。此处有待进一步学习。

desc.newInstance：该方法通过反射的方式调用无参构造方法新建一个对象。

　　这里就可以理解为什么发序列化后会破坏单例。怎么解决呢？还是上面的代码：

hasReadResolveMethod:如果实现了serializable 或者 externalizable接口的类中包含readResolve则返回true

invokeReadResolve:通过反射的方式调用要被反序列化的类的readResolve方法。

所以我们只需要在类中实现readResolve方法即可。

private Object readResolve() {
    return singleton;
}

• 反射对单例的破坏
  　　Java中的反射技术可以获取类的所有方法、成员变量，还能访问private的构造方法，这样一来，单例模式中用的私有构造函数被调用就会产生多个实例。

Constructor con = Singleton.class.getDeclaredConstructor();  
con.setAccessible(true);  
// 通过反射获取实例  
Singleton newInstance = (Singleton)con.newInstance();
//判断是否是同一个对象
System.out.println(newInstance == Singleton.getSingleton());

　　最终结果输出是 false。为了防止反射破坏单例模式，可以在构造函数调用时进行处理，当构造函数第2次被调用时抛出异常！

private static boolean flag = false;  

private Singeton(){  
    if(flag){  
        flag = !flag;  
    }else{  
        try {  
            throw new Exception("duplicate instance create error!" + Singeton.class.getName());  
        } catch (Exception e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        }  
    }  
}