单例模式的应用

单例模式定义：
单例模式(Singlleton Pattern) 是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。单例模式是创建型模式。单例模式在现实生活中应用也非常广泛，例如公司CEO，部门经理等。J2EE标准中的ServletContext、ServletContextConfig等，Spring框架应用中ApplicationContext、数据库的连接池等也都是单例形式。

一、饿汉式单例

饿汉式在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以天生是线程安全的。

• 优点：保证线程绝对安全，执行效率高，没有任何的锁
• 缺点：所有对象类加载的时候就实例化，系统初始化就会导致大量的内存浪费

//饿汉式单例类.在类初始化时，已经自行实例化 
public class Singleton {
    private Singleton() {}
    private static final Singleton single = new Singleton();
    //静态工厂方法 
    public static Singleton getInstance() {
        return single;
    }
}

二、懒汉式单例

优点：解决了饿汉式单例可能带来的内存浪费问题，节省内存
缺点：线程不安全的问题

//懒汉式单例类.在第一次调用的时候实例化自己 
public class Singleton {
    private Singleton() {}
    private static Singleton single=null;
    //静态工厂方法 
    public static Singleton getInstance() {
         if (single == null) {  
             single = new Singleton();
         }  
        return single;
    }
}

• 针对上述懒汉式单例存在线程安全，在多线程情况下，会生成多个实例，不满足单例模式；所以提出如下饿汉式线程安全单例模式
  饿汉式线程安全

public class Singleton {
    private Singleton() {}
    private static Singleton single=null;
    //静态工厂方法 
    public static synchronized Singleton getInstance() {
         if (single == null) {  
             single = new Singleton();
         }  
        return single;
 }
}

• 通过使用synchronized加锁时，在线程比较多的情况下，如果CUP分配压力上升，则会导致大批线程阻塞，从而导致程序性能下降。那么就引出了下边的双重检查锁的单例模式，(备注：synchronized是互斥锁，同一时刻只有一个线程能够访问方法)

双重检查锁

public class Singleton {
    private Singleton() {}
    private static volatile Singleton single=null;
    public static Singleton getInstance() {
         //第一层:双重检查锁的作用  
        if (singleton == null) {  
            synchronized (Singleton.class) {  
            //第二层:是为了减少线程对同步锁的竞争
               if (singleton == null) {  
                  singleton = new Singleton(); 
               }  
            }  
        }  
        return singleton; 
    }

单例模式-双重检查加锁为什么需要加上volatile关键字？
双重检查锁单例模式为什么要用volatile关键字？

上述的双重检查锁虽然做了优化，但是仍然要使用synchronized关键字，对程序性能还是存在一定影响的。于是我们引入了如下的静态内部类形式的单例，从类初始化的角度来考虑，看如下代码采用了静态内部类的方式。

静态内部类
优点：写法优雅，利用了Java本身语法特点，性能奥，避免了内存浪费
缺点：能够被反射破坏

public class Singleton {  
    private static class LazyHolder {  
       private static final Singleton INSTANCE = new Singleton();  
    }  
    private Singleton (){}  
    public static final Singleton getInstance() {  
       return LazyHolder.INSTANCE;  
    }  
}  

三、反射破坏单例

一个单例对象创建好后，有时候需要将对象序列化然后写入磁盘，下次使用时再从磁盘中读对象进行反序列化，将其转换为内存对象。反序列化后的对象会重新分配内存，即重新创建。如果序列化的目标对象为单例对象，就违背了单例模式的初衷，相当于破坏了单例，来看一段代码：

public class Singleton {  
    private static class LazyHolder {  
       private static final Singleton INSTANCE = new Singleton();  
    }  
    private Singleton (){}  
    public static final Singleton getInstance() {  
       return LazyHolder.INSTANCE;  
    }  
}  

//单例模式，通过反射获取实例

public class ReflectTest {

    public static void main(String[] args) {
        try {
            Class<?> clazz = Singleton.class;
            //获取该单例类的空构造器
            Constructor c = clazz.getDeclaredConstructor(null);
            //绕过私有权限
            c.setAccessible(true);

            Object instance1 = c.newInstance();
            Object instance2 = c.newInstance();
            System.out.println(instance1);
            System.out.println(instance2);
            System.out.println(instance1 == instance2);

        }catch (Exception e){
            e.printStackTrace();
        }
    }

通过反射获得单例类的构造函数，由于该构造函数是private的，通过setAccessible(true)指示反射的对象在使用时应该取消 Java 语言访问检查,使得私有的构造函数能够被访问，这样使得单例模式失效。

//自认为史上最牛的单例模式的实现方式
public class Singleton {  
    //使用LazyHolder的时候，默认会先初始化内部类
    //如果没使用，则内部类不加载的
    private static class LazyHolder {  
       private static final Singleton INSTANCE = new Singleton();  
    }  
    // 每一个关键字都不是多余的，static是为了使单例的空间共享，保证这个放啊不会被重写、重载
    private Singleton (){
       if(LazyHolder.INSTANCE!=null){
       //在返回结构以前，一定会先加载内部类
           throw new RuntimeException("不允许创建多个实例！");
       }
    }  
    // 默认不加载
    public static final Singleton getInstance() {  
       return LazyHolder.INSTANCE;  
    }  
}  

四、序列化破坏单例

一个单例对象创建好后，有时候需要将对象序列化然后写入磁盘，下次使用时再从磁盘中读取对象，并进行反序列化，将其转化为内存对象。反序列化后的对象会重新分配内存，即重新创建。如果序列化的目标对象为单例对象，就违背了单例模式的初衷，相当于违背了单例模式。

public class SeriableSingleton implements Serializable {


    //序列化
    //把内存中对象的状态转换为字节码的形式
    //把字节码通过IO输出流，写到磁盘上
    //永久保存下来，持久化

    //反序列化
    //将持久化的字节码内容，通过IO输入流读到内存中来
    //转化成一个Java对象


    public  final static SeriableSingleton INSTANCE = new SeriableSingleton();
    private SeriableSingleton(){}

    public static SeriableSingleton getInstance(){
        return INSTANCE;
    }

}

public class SeriableSingletonTest {
    public static void main(String[] args) {

        SeriableSingleton s1 = null;
        SeriableSingleton s2 = SeriableSingleton.getInstance();

        FileOutputStream fos = null;
        try {

            fos = new FileOutputStream("SeriableSingleton.obj");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(s2);
            oos.flush();
            oos.close();

            FileInputStream fis = new FileInputStream("SeriableSingleton.obj");
            ObjectInputStream ois = new ObjectInputStream(fis);
            s1 = (SeriableSingleton)ois.readObject();
            ois.close();

            System.out.println(s1);
            System.out.println(s2);
            System.out.println(s1 == s2);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

从运行结果可以看出，反序列化后的对象和手动创建的对象是不一致的，实例化了两次，违背了单例设计模式的初衷。那么，我们如何保证在序列化的情况下，也能够实现单例模式呢，其实很简单，只要增加readResolve()方法即可。

public class SeriableSingleton implements Serializable {


    //序列化
    //把内存中对象的状态转换为字节码的形式
    //把字节码通过IO输出流，写到磁盘上
    //永久保存下来，持久化

    //反序列化
    //将持久化的字节码内容，通过IO输入流读到内存中来
    //转化成一个Java对象


    public  final static SeriableSingleton INSTANCE = new SeriableSingleton();
    private SeriableSingleton(){}

    public static SeriableSingleton getInstance(){
        return INSTANCE;
    }

    private Object readResolve(){ return INSTANCE;}

}

为什么写了readResolve方法，反序列化就不会破坏单例呢？原因如下：
ObjectInputStream的readOrdinaryObject(boolean unshared)方法

   private Object readOrdinaryObject(boolean unshared)
        throws IOException
    {
        if (bin.readByte() != TC_OBJECT) {
            throw new InternalError();
        }

        ObjectStreamClass desc = readClassDesc(false);
        desc.checkDeserialize();

        Class<?> cl = desc.forClass();
        if (cl == String.class || cl == Class.class
                || cl == ObjectStreamClass.class) {
            throw new InvalidClassException("invalid class descriptor");
        }

        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);
        }

        passHandle = handles.assign(unshared ? unsharedMarker : obj);
        ClassNotFoundException resolveEx = desc.getResolveException();
        if (resolveEx != null) {
            handles.markException(passHandle, resolveEx);
        }

        if (desc.isExternalizable()) {
            readExternalData((Externalizable) obj, desc);
        } else {
            readSerialData(obj, desc);
        }

        handles.finish(passHandle);
        //重点：这里的意思就是：如果有写readResolve方法，就调用readResovle方法
        if (obj != null &&
            handles.lookupException(passHandle) == null &&
            desc.hasReadResolveMethod())
        {
            //反射调用ReadResolve方法
            Object rep = desc.invokeReadResolve(obj);
            if (unshared && rep.getClass().isArray()) {
                rep = cloneArray(rep);
            }
            if (rep != obj) {
                handles.setObject(passHandle, obj = rep);
            }
        }

        return obj;
    }

看到上面应该很清楚了，在条件判断中 desc.hasReadResolveMethod()会判断是否有readResolve()方法，如果有的话会通过desc.invokeReadResolve(obj)去反射调用该方法，返回的就是同一个对象。

教你破坏单例模式

序列化破坏单例&反射破坏单例

通过JDK源码分析我们可以看出，虽然增加了readResolver()方法返回实例解决了单例模式别破坏的问题，但是实际上实例化了两次，只不过新创建的对象并没有被返回而已。如果创建对象的动作发生频率加快，就意味着内存分配开销也会随之增大。于是引入了 下边注册时的单例模式。

五、注册式单例模式

注册式单例模式又称为登记式单例模式，就是将每一个实例都登记到某一个地方，使用唯一的标识，注册式单例模式有两种:一种为枚举式单例模式，另一种为容器式单例模式。
1、枚举式单例模式

public enum EnumSingleton {
    INSTANCE;

    private Object data;

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

    public static EnumSingleton getInstance(){return INSTANCE;}
}

• 枚举式单例能够防止序列化破坏单例
  使用非常好用的反编译工具Jad，解压之后配置好环境变量，就可以使用命令行调用了。找到工程所在Class目录，复制EnumSingleton.class所在的路径。
  然后切换命令行，切换到工程所在的Class目录，输入命令jad并在后面输入复制好的路径，在Class目录下边会多出一个EnumSingleton.jad文件。打开EnumSingleton.jad文件,我们惊奇的发现有如下代码：

staic 
{
    INSTANCE = new EnumSingleton("INSTANCE",0);
    $VALUES  = (new EnumSingletion[]{
          INSTANCE
    });
}

原来，枚举类单例模式在静态代码块中就给INSTANCE进行了复制，是饿汉式单例模式的实现。
至此，我们还可以试想，序列化能否破坏枚举式单例模式呢？

private Object readObject0(){
   ...
   case TC_ENUM:
      return checkResolve(readEnum(unshared));
   ...
}

我们看到，在readObject0()中调用了readEnum()方法，来看readEnum()方法的代码实现：

private Enum<?> readEnum(boolean unshared) throws IOException {
        if (bin.readByte() != TC_ENUM) {
            throw new InternalError();
        }

        ObjectStreamClass desc = readClassDesc(false);
        if (!desc.isEnum()) {
            throw new InvalidClassException("non-enum class: " + desc);
        }

        int enumHandle = handles.assign(unshared ? unsharedMarker : null);
        ClassNotFoundException resolveEx = desc.getResolveException();
        if (resolveEx != null) {
            handles.markException(enumHandle, resolveEx);
        }

        String name = readString(false);
        Enum<?> result = null;
        Class<?> cl = desc.forClass();
        if (cl != null) {
            try {
            //核心代码：通过类名和类对象找到一个唯一的枚举对象。
                @SuppressWarnings("unchecked")
                Enum<?> en = Enum.valueOf((Class)cl, name);
                result = en;
            } catch (IllegalArgumentException ex) {
                throw (IOException) new InvalidObjectException(
                    "enum constant " + name + " does not exist in " +
                    cl).initCause(ex);
            }
            if (!unshared) {
                handles.setObject(enumHandle, result);
            }
        }

        handles.finish(enumHandle);
        passHandle = enumHandle;
        return result;
    }

• 枚举式单例能够防止反射破坏单例
  枚举式单例在初始化的时候使用静态代码块，饿汉式；在初始化实例的时候JDK中也有判断

    public T newInstance(Object ... initargs)
        throws InstantiationException, IllegalAccessException,
               IllegalArgumentException, InvocationTargetException
    {
        if (!override) {
            if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                Class<?> caller = Reflection.getCallerClass();
                checkAccess(caller, clazz, null, modifiers);
            }
        }
        //JDK中的判断，如果是枚举，就无法生成实例 
        if ((clazz.getModifiers() & Modifier.ENUM) != 0)
            throw new IllegalArgumentException("Cannot reflectively create enum objects");
        ConstructorAccessor ca = constructorAccessor;   // read volatile
        if (ca == null) {
            ca = acquireConstructorAccessor();
        }
        @SuppressWarnings("unchecked")
        T inst = (T) ca.newInstance(initargs);
        return inst;
    }

从上述代码可以看出，在newInstance()方法中做了强制性判断，如果修饰符Modifier.ENUM枚举类型，则直接抛出异常。这个地方和静态内部类的处理方式有异曲同工之妙。对，但是我们自己在构造方法中写逻辑处理可能存在未知的风险，而JDK的处理是最官方、最权威、最稳定的。因为枚举式单例模式也是《Effective Java》书中推荐的一种单例模式实现写法。

六、

四、静态内部类

2.容器式单例
其实枚举式单例，虽然写法优雅，但是也会有一些问题。因为它在类加载之时就将所有的对象初始化放在类内存中，这其实和饿汉式并无差异，不适合大量创建单例对象的场景。那么接下来看注册式 单例模式的另一种写法，即容器式单例模式，创建ContainerSingleton类

public class ContainerSingleton {

    private ContainerSingleton(){}

    private static Map<String,Object> ioc = new ConcurrentHashMap<String, Object>();

    public static Object getInstance(String className){
        Object instance = null;
        if(!ioc.containsKey(className)){
            try {
                instance = Class.forName(className).newInstance();
                ioc.put(className, instance);
            }catch (Exception e){
                e.printStackTrace();
            }
            return instance;
        }else{
            return ioc.get(className);
        }
    }

}

容器式单例模式适用于需要大量创建单例对象的场景，便于管理。但是它是非线程安全的。到此，
注册式单例模式介绍完毕。我们再来看看Spring中的容器式单例模式的实现代码：

六、ThreadLocal单例模式

package nju.java.pattern.singleton_pattern;
 
/**
 * 线程单例实现ThreadLocal
 * ThreadLocal 保证其创建的对象是全局唯一的，
 * 但是能保证在单个线程中是唯一的，天生是线程安全的
 */
public class ThreadLocalSingleton {
    public static final ThreadLocal<ThreadLocalSingleton> threadLocalInstance=
            new ThreadLocal<ThreadLocalSingleton>(){
                @Override
                protected ThreadLocalSingleton initialValue(){
                    return new ThreadLocalSingleton();
                }
            };
    private ThreadLocalSingleton(){}
 
    public static ThreadLocalSingleton getInstance(){
        return threadLocalInstance.get();
    }
}