三：单例设计模式详解

单例模式是指确保一个类在任何情况下都绝对只有一个实例，并且提供一个全局访问点。

J2EE标准中的ServlentContext,SerlentContextConfig等，Spring框架应用中的ApplicationContext，数据库的连接池等也是单例形式

单例分为饿汉式和懒汉式

饿汉式：在类加载的时候就立即初始化，并且创建单例对象，绝对是线程安全的，在线程还没有出现前就实例化了

public class HungrySingleton {
    private static final HungrySingleton hun = new HungrySingleton();

    public HungrySingleton() {
    }
    public static HungrySingleton getInstance(){
        return hun;
    }
}

public class HungrySingleton {
    private static final HungrySingleton hun;
    static {
        hun = new HungrySingleton();
    }

    public HungrySingleton() {
    }
    public static HungrySingleton getInstance(){
        return hun;
    }
}

有两种写法

Spring容器ApplicationContext就是典型的饿汉式单例模式

懒汉式：被外部调用时候才会加载

public class LazySingleton {
    public LazySingleton() {
    }
    private static LazySingleton lazy = null;
    public static LazySingleton getInstance(){
        if(lazy == null){
            lazy = new LazySingleton();
        }
        return lazy;
    }
}

多线程情况下

public class ExeThread implements Runnable {
    @Override
    public void run() {
        LazySingleton singleton = LazySingleton.getInstance();
        System.out.println(Thread.currentThread().getName()+":"+singleton);
    }
}

public class LazySimplentontTest {
    public static void main(String[] args) {
        Thread t1 = new Thread(new ExeThread());
        Thread t2 = new Thread(new ExeThread());
        t1.start();
        t2.start();
        System.out.println("--------------");
    }
}

存在线程不安全，加锁能解决但是会存在性能问题

为了避开这两个缺点，采用静态内部类

public class LazySingleton {
    public LazySingleton() {
    }
    private static LazySingleton lazy = null;
    public static final LazySingleton getInstance(){
       return LazyHolder.LAZY;
    }
    //启动时只加载一次
    public static class LazyHolder{
        private static final LazySingleton LAZY = new LazySingleton();
    }
}

这种方式既解决了性能问题又解决了安全问题

反射可以破坏单例

public class LazySimplentontTest {
    public static void main(String[] args) throws Exception {
        //获取对象字节码
        Class<?> lazySingletonClass = LazySingleton.class;
        //通过反射获取私有的构造器方法
        Constructor declaredConstructors = lazySingletonClass.getDeclaredConstructor(null);
        //强制访问
        declaredConstructors.setAccessible(true);
        //强制初始化
        Object o1 = declaredConstructors.newInstance();
        //初始化两次，犯了单例原则
        Object o2 = declaredConstructors.newInstance();
        System.out.println(o1 == o2);//false
    }

可以在构造器里面加判断，让其不能创建构造器

//默认先初始化内部类，如果没有使用，则内部类是不加载的
public LazySingleton() {
    if(LazyHolder.LAZY !=null){
        throw new  RuntimeException("不允许创建多个对象");
    }
}

序列化也会破坏单例，将对象写入磁盘然后在读取进行反序列化，重新分配内存，即重新创建，如果序列化的对象是单例对象，又违背了单例式的初衷

public class SeriableSingleton implements Serializable {
    private final static SeriableSingleton  SIN = new SeriableSingleton();

    public SeriableSingleton() {
    }
    public static SeriableSingleton getInstance(){
        return SIN;
    }
}

public class SeriableSingletonTest{
    public static void main(String[] args) {
        SeriableSingleton s1 = null;
        SeriableSingleton s2 = SeriableSingleton.getInstance();
        FileOutputStream file = null;
        try
        {
            file = new FileOutputStream("SeriableSingleton.obj");
            ObjectOutputStream oos = new ObjectOutputStream(file);
            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（）方法即可，这样当JVM从内存中反序列化地"组装"一个新对象时,就会自动调用这个 readResolve方法来返回我们指定好的对象了, 单例规则也就得到了保证.

原因如下，看JDK源码 ：

由ObjectInputStream类readObject（）方法进入

重点这个地方，又调用

重点这个地方，又调用readOrdinaryObject（）方法

 

就是简单的判断一下构造器是否为空，这意味着只要有无参构造器方法就会实例化，这时候加上 readResolve（）方法就是避免了单例模式被破坏的真正原因，继续看 ObjectInputStream类中的readOrdinaryObject（）方法

上面方法的逻辑就是通过反射找到一个无参的readResolve（）的方法，并且保存下来

再继续readOrdinaryObject（）方法往下看

可以看到该方法中用了反射调用了readResolveMethod方法，其实是实例化了两次 ，只不过新创建的对象没有被返回而已

如果创建对象的动作频率加快，就意味着内存分配开销也会加大，是否有提升空间？

注册单例可能会帮助我们

注册单例分两种，枚举 式单例和容器式单例

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

public class EnumSingleTest {
    public static void main(String[] args) {
        try{
            EnumSingleton singleton1 = null;
            EnumSingleton singleton2=EnumSingleton.getInstance();
            singleton2.setData(new Object());
            FileOutputStream file = new FileOutputStream("EnumSingleton.obj");
            ObjectOutputStream oos = new ObjectOutputStream(file);
            oos.writeObject(singleton2);
            oos.flush();
            oos.close();
            FileInputStream fis = new FileInputStream("EnumSingleton.obj");
            ObjectInputStream ois = new ObjectInputStream(fis);
            singleton1 = (EnumSingleton)ois.readObject();
            ois.close();
            System.out.println(singleton1);
            System.out.println(singleton2);
            System.out.println(singleton1 == singleton2);
        }catch (Exception e){
            e.printStackTrace();
        }

    }
}

通过反编译工具可以看到EnumSingleton中的方法

原来枚举式单例模式在静态代码块中就给INSTANCE进行赋值，是饿汉式单例的实现

序列化是否能破坏枚举呢？

继续看ObjectInputStream类的readObject0（）方法

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

可以看出枚举类型其实是通过类名和类对象找到一个唯一的枚举对象，所有枚举对象不可能被类加载器加载多次

反射是否能破坏单例？

报错异常，没有找到无参构造器，查看Enum的源码发现，只要一个有参的protected的构造器

报错，即不能用反射来创建枚举类型，看源码...

源码里面做出了强制性判断，如果修饰符是Modifier.ENUM枚举类型的就直接抛出异常

所以大家应该可以明白了，JDK源码的语法为枚举做了保护，让枚举式单例成为一种比较优雅的实现 

容器式单例，适用于实例非常多的情况下，便于管理，但是他是非线程安全的

线程单例ThreadLocal，不能保证其创建的对象全局唯一性，但是能保证在单个线程中是惟一的，天生线程安全

public class ThreadLocalSing {
    private ThreadLocalSing() {
    }

    public static ThreadLocalSing getInstance() {
        return th.get();
    }

    private static final ThreadLocal<ThreadLocalSing> th = new ThreadLocal<ThreadLocalSing>() {
        @Override
        protected ThreadLocalSing initialValue() {
            return new ThreadLocalSing();
        }
    };
}

public class ThreadTest {
    public static void main(String[] args) {
        System.out.println(ThreadLocalSing.getInstance());
        System.out.println(ThreadLocalSing.getInstance());
        System.out.println(ThreadLocalSing.getInstance());
        System.out.println(ThreadLocalSing.getInstance());
        Thread t1 = new Thread(new ExeThread());
        Thread t2 = new Thread(new ExeThread());
        t1.start();
        t2.start();

    }
}

不管调用多少次，都是一个实例，但是多线程时获取不同实例