单例模式详解

前言

单例模式是确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。实际业务中如J2EE里的ServletContext,Spring中的ApplicationContext等都是单例模式

饿汉式单例模式

饿汉式单例模式在类加载的时候就立即初始化，并且创建单例对象。

public class HungrySingleton {
    private static final HungrySingleton hungrySingleton = new HungrySingleton();
    private HungrySingleton() {}
    public static HungrySingleton getInstance(){
        return hungrySingleton;
    }
}

单例模式首先将默认构造函数私有化
饿汉式单例模式因为在类加载的时候就创建对象，所以往往会造成内存浪费，因为并不是所有的单例对象都会被用到。所有此时就出现了懒汉式单例模式

懒汉式单例模式

最初形态

LazySimpleSingleton ：

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

代码中，我们先定义单例对象为null，然后在实例化的时候，判断单例对象是否为null，如果为null，则创建，不为null就用之前创建的对象。
但是这个代码是有问题的，会有线程安全的问题，我们使用的代码测试一下
线程类ExectorThread ：

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

LazySimpleSingletonTest ：

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

这段代码中，我们使用多线程来调用这个单例
我们在LazySimpleSingleton 打上断点

然后断点使用Thread状态

Debug执行测试

通过不断切换线程，让两个线程都进入if里面

最后我们看到两个线程调用的对象是不同的

使用synchronized线程同步

我们对单例创建方法使用synchronized来修饰使方法线程同步

在这里插入代码片

执行测试

我们可以看到Thread-0线程运行的时候，Thread-1处于MONITOR排队，一直要等到Thread-0运行出这个方法，Thread-1才能变成RUNNING状态
但是这种方法在线程比较多得情况下，会导致大量阻塞，从而影响性能，那么怎么解决这个问题呢

双重检查锁

LazySimpleSingleton ：

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

这个方法中，当第一个线程进入时第二个线程也可以进入，只有到线程到synchronized才会上锁，后面的线程变成MONITOR状态，当第一个线程执行完方法后，后面没有进入第一个if方法里的线程全部可以直接异步走完

采用静态内部类

上面使用双重检查锁虽然大大解决了阻塞带来的性能问题，但是使用synchronized总归还是要上锁，那么还有什么更好的方法既解决饿汉式的内存浪费问题和synchronized的性能问题呢，这里就可以使用静态内部类了

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

在这个类中，我们使用到了私有化的静态内部类，这个类默认是不加载的，只有在调用的时候才加载，然后里面定义的LAZY相当于一个常量，所以一旦定义好就不会改变，这样就解决了线程安全问题。

反射破坏单例

上面的案例中，单例的构造方法除了加上private关键字，没有做任何处理。如果我们使用反射来调用其构造方法，再调用getInstance方法，就会有两个不同的实例

LazyInnerClassSingletonTest ：

public class LazyInnerClassSingletonTest {
    public static void main(String[] args) {
        try{
            Class<?> clazz = LazyInnerClassSingleton.class;
            //通过反射获取私有构造方法
            Constructor c = clazz.getDeclaredConstructor(null);
            //强制访问
            c.setAccessible(true);
            //暴力初始化
            Object o1 = c.newInstance();
            Object o2 = c.newInstance();
            System.out.println(o1 == o2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

测试结果如下：

解决方法是我们在构造方法中做出一些限制

public class LazyInnerClassSingleton {
    private LazyInnerClassSingleton() {
        if(LazyHolder.LAZY != null) {
            throw new RuntimeException("不允许创建多个实例");
        }
    }
    public static final LazyInnerClassSingleton getInstance() {
        return LazyHolder.LAZY;
    }
    private static class LazyHolder{
        private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton();
    }
}

测试结果如下：

序列化破坏单例

示例

首先我们定义一个懒汉式的单例
SeriableSingleton ：

public class SeriableSingleton implements Serializable {
    public final static SeriableSingleton INSTANCE = new SeriableSingleton();
    private SeriableSingleton() {}
    public static SeriableSingleton getInstance(){
        return INSTANCE;
    }
}

然后我们在测试中使用序列化破坏单例
SeriableSingletonTest ：

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方法即可
SeriableSingleton ：

public class SeriableSingleton implements Serializable {
    public final static SeriableSingleton INSTANCE = new SeriableSingleton();
    private SeriableSingleton() {}
    public static SeriableSingleton getInstance(){
        return INSTANCE;
    }
    private Object readResolve() {
        return INSTANCE;
    }
}

测试结果如下

注册式单例

注册式单例又登记式单例，就是将每一个实例都登记到某一个地方，使用唯一的标识获取实例。注册式单例有两种：枚举式和容器式

枚举式单例

EnumSingleton ：

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

枚举式单例式一种饿汉式单例模式，反射和序列化都不能破坏其单例

容器式单例

ContainerSingleton ：

public class ContainerSingleton {
    private ContainerSingleton() {}
    private static Map<String,Object> ioc = new ConcurrentHashMap<>();
    public static Object getBean(String className) {
        synchronized (ioc) {
            if(!ioc.containsKey(className)) {
                Object obj = null;
                try{
                    obj = Class.forName(className).newInstance();
                    ioc.put(className,obj);
                }catch (Exception e){
                    e.printStackTrace();
                }
                return obj;
            } else {
                return ioc.get(className);
            }
        }
    }
}

容器式单例式非线程安全的