Java设计模式——单例模式

概述

一个类在全局只需要一个实例，例如线程池，缓存注册或者配置对象。

实现方式

1. 饿汉式
2. 懒汉式
3. 注册式
4. 静态内部类
5. 枚举式

饿汉式单例

/**
 * 饿汉式单例，它是在类加载的时候就立即初始化，并且创建单例对象
 * 优点：没有加任何的锁、执行效率比较高，在用户体验上来说，比懒汉式更好
 * 缺点：类加载的时候就初始化，不管你用还是不用，我都占着空间
 * 浪费了内存，有可能占着茅坑不拉屎
 * 绝对线程安全，在线程还没出现以前就是实例化了，不可能存在访问安全问题
 *
 * CountDownLatch是一个计数器，它使得一个线程等待其他各自线程执行完毕之后再执行
 * 线程完成一个记录一个，计数器递减，当计数器值为0时，表示所有线程执行完成，在闭锁上
 * 等待的线程就可以恢复工作了
 */
public class HungerSingleton {
    private HungerSingleton(){}
    private static HungerSingleton singleton=new HungerSingleton();
    public static HungerSingleton getInstance(){
        return singleton;
    }
    public static class ThreadTest implements Runnable{
        private static CountDownLatch countDownLatch;
        public ThreadTest(CountDownLatch countDownLatch) {
            this.countDownLatch = countDownLatch;
        }
        @Override
        public void run() {
            try {
                countDownLatch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            HungerSingleton hungrySingleton = HungerSingleton.getInstance();
            System.out.println(Thread.currentThread().getName() +":"+hungrySingleton);
        }
    }
    public static void main(String[] args) {
        //CountDownLatch(int count)唯一构造器
        CountDownLatch cdl = new CountDownLatch(1000);
        for(int i=0;i<1000;i++){
            Thread t = new Thread(new HungrySingleton.TestThread(cdl),i+"");
            t.start();
            cdl.countDown();
        }
    }
}

懒汉式单例

实现方式一

/**懒汉可以理解为延迟加载，相比于用静态变量的方式，只有在使用的时候才会初始化对象
 * 
 * 这种写法非线程安全
 */
public class LazySingleton {
    private LazySingleton() {
    }
    private static LazySingleton lazySingleton = null;
    public static LazySingleton getInstance(){
        //会存在线程安全问题，假设27行 new的过程需要5s，并发情况下代码在26行判断的时候是null，一起阻塞在27行，5s后产生大量对象
        if(null==lazySingleton){
            lazySingleton = new LazySingleton();
        }
        return lazySingleton ;
    }
    public static class TestThread2 implements Runnable{
        private static CountDownLatch cd;
        public TestThread2(CountDownLatch countDownLatch) {
            this.cd = countDownLatch;
        }
        @Override
        public void run() {
            try {
                cd.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            LazySingleton lazySingleton = LazySingleton.getInstance();
            System.out.println(Thread.currentThread().getName() +":"+lazySingleton);
        }
    }
    public static void main(String[] args) {
        CountDownLatch cdl = new CountDownLatch(100);
        for(int i=0;i<100;i++){
            Thread t = new Thread(new TestThread2(cdl),i+"");
            t.start();
            cdl.countDown();
        }
    }
}

实现方式二（Synchronized修饰方法）

public class LazySingletonSynchronized {
    private LazySingletonSynchronized() {
    }
    //volatile保证多线程间的可见性，防止A线程创建对象后没有即时通知到B线程，B线程重现创建
    private static LazySingletonSynchronized lazySingleton = null;
    /**
     * 这个方法简单粗暴，保证了线程安全，达到了延迟加载的目的，但是存在的问题是每次进行getInstance的时候需要加锁，性能不是很好
     * @return
     */
    public static synchronized LazySingletonSynchronized getInstance(){
        if(null==lazySingleton){
            lazySingleton = new LazySingletonSynchronized();
        }
        return lazySingleton ;
    }
    public static class TestThread3 implements Runnable{
        private static CountDownLatch cd;
        public TestThread3(CountDownLatch countDownLatch) {
            this.cd = countDownLatch;
        }
        @Override
        public void run() {
            try {
                cd.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            LazySingletonSynchronized lazySingleton = LazySingletonSynchronized.getInstance();
            System.out.println(Thread.currentThread().getName() +":"+lazySingleton);
        }
    }

分析

线程安全，懒加载。但是由于方法加锁，多线程的情况下性能不好。

仔细分析使用场景，发现第一次创建类对象的时候给方法加锁是对的，由于锁是加在方法上，当创建完对象后，每次获取实例仍然进行了加锁操作，这是可以优化的地方，所以有了下面的实现方式三

实现方法三（double check）

public class DoubleCheckSingleton {
    private static volatile DoubleCheckSingleton doubleCheckSingleton ;
    private DoubleCheckSingleton(){}
    /**
     * 优点：实现了延时加载，性能更佳，锁粒度更小，减少竞争。因为大部分情况第一次null判断返回的是false,就不需要进入锁了
     * @return
     */
    public static DoubleCheckSingleton getInstance(){
        if( null==doubleCheckSingleton){
            synchronized (DoubleCheckSingleton.class){
                if(null==doubleCheckSingleton){
                    doubleCheckSingleton = new DoubleCheckSingleton();
                }
            }
        }
        return doubleCheckSingleton;
    }
}

分析

synchronized如何保证可见性？原来获取锁的线程在释放锁之前会把工作内存中修改过的变量同步到主内存中，当其他线程重新获取同一个锁之后会重新获取主内存中的数据到自己的工作内存中去操作。

• 第一个null判断作用当对象创建完成后，读取对象的时候直接返回已经创建好的对象，优化了性能
• 第二个null判断是避免当前线程获取到锁之后，对象已经被上一个获取到锁的线程创建完。
• 声明对象的时候要用volatile修饰。假设A，B线程都从主内存拷贝了一份到自己的线程中操作，A线程创建了对象，如果不用volatile修饰，B线程是不可见的，会导致创建多个实例

注册式单例

/**
 * 将对象的class作为key，实例对象作为value放入一个线程安全的集合容器中，
 * 容器中没有则利用反射创建实例，否则从容器中获取已经创建的实例
 */
public class SingletonManager {
    //线程安全的容器,饿汉式保证容器对象本身为单例
    private static Map map = new ConcurrentHashMap();
    //外部访问点,传入类名,返回该类的单例对象.该类会被登记进入上面的容器进行单例管理
    //在类中务必保证构造方法私有化,对这一点这个管理类是无法控制的,需要自己保证
    public static Object getInstance(String className) {
        //如果还没登记到容器
        if (!map.containsKey(className)) {
            //用反射的方式创建对象(因为已经构造函数私有化),并登记到容器中
            try {
                map.put(className, Class.forName(className).newInstance());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        //从容器中获取管理的单例对象并返回
        return map.get(className);
    }
}

静态内部类

public class InnerClassSingleton  implements Serializable {
    private InnerClassSingleton() {
    }
    private static class InnerClassSingletonHolder{
        private static InnerClassSingleton innerClassSingleton = new InnerClassSingleton();
    }
    public static InnerClassSingleton getInstance(){
        return InnerClassSingletonHolder.innerClassSingleton;
    }
}

实现单例需要注意的点

为了实现单例模式，其核心就是确保单例对象的唯一性

• 无法通过new来随意创建对象，构造函数为private
• 提供获取唯一实例对象的方法，通常是getInstance
• 多线程并发的情况下保证唯一
• 避免反射创建单例对象（反射攻击）
• 避免通过序列化创建单例对象（如果单例类实现了Serializable）（序列化攻击）

由此可以利用Enum的天然属性，可以有效的保证上面的几个关键点。它属于饿汉模式的单例实现

/**
 * 使用枚举实现单例。
 */
public enum EnumSingleton {
    INSTANCE; // 唯一的实例对象
    public static EnumSingleton getInstance() {
        return INSTANCE;
    }
    // 单例对象的属性对象
    private Object obj = new Object();
    public Object getObj() {
        return obj;
    }
    /**
     * 单例提供的对外服务。
     */
    public Object getFactoryService() {
        return new Object();
    }
}

上述代码的反编译代码

public final class EnumSingleton extends Enum
{
    public static EnumSingleton[] values()
    {
        return (EnumSingleton[])$VALUES.clone();
    }
    public static EnumSingleton valueOf(String name)
    {
        return (EnumSingleton)Enum.valueOf(com/ws/pattern/singleton/EnumSingleton, name);
    }
    // 无法通过new来随意创建对象，构造函数为private.
    private EnumSingleton(String s, int i)
    {
        super(s, i);
        obj = new Object();
    }
    // 提供获取唯一实例对象的方法，通常是getInstance
    public static EnumSingleton getInstance()
    {
        return INSTANCE;
    }
    public Object getObj()
    {
        return obj;
    }
    public Object getFactoryService()
    {
        return new Object();
    }
    // 提供获取唯一实例对象的方法，通常是getInstance
    // 也可以直接获取到INSTANCE，但是获取到的都是一个对象
    public static final EnumSingleton INSTANCE;
    private Object obj;
    private static final EnumSingleton $VALUES[];
    // 静态代码中实例化对象，多线程并发的情况下保证唯一，属于饿汉模式
    static 
    {
        INSTANCE = new EnumSingleton("INSTANCE", 0);
        $VALUES = (new EnumSingleton[] {
            INSTANCE
        });
    }
}

从反编译代码中我们可以看到Enum的本质：

• 枚举本质上是个final类
• 定义的枚举值实际上就是一个枚举类的不可变对象（比如这里的INSTANCE）
• 在Enum类加载的时候，就已经实例化了这个对象
• 无法通过new来创建枚举对象

Enum实现单例模式的几个关键点验证

1.避免反射创建单例对象（反射攻击）

/**
 * 反射攻击。
 * 由于Enum天然的不允许反射创建实例，所以可以完美的防范反射攻击。
 */
private static void reflectionAttack() {
    System.out.println("反射攻击单例对象-----------开始");
    try {
        Constructor con = EnumSingleton.class.getDeclaredConstructor(String.class, int.class);
        con.setAccessible(true);
        Object obj = con.newInstance("INSTANCE", 0); // 反射新建对象以破坏单例
        System.out.println(obj);
        System.out.println(EnumSingleton.getInstance());
    } catch (Exception e) {
        e.printStackTrace();
    }
    System.out.println("反射攻击单例对象-----------结束");
}

分析

代码运行后，会抛出异常"java.lang.IllegalArgumentException: Cannot reflectively create enum objects"

Exception in thread "main" java.lang.IllegalArgumentException: Cannot reflectively create enum objects
   at java.lang.reflect.Constructor.newInstance(Constructor.java:416)
   at com.ws.pattern.singleton.EnumSingletonAppMain.reflectionAttack(EnumSingletonAppMain.java:43)
   at com.ws.pattern.singleton.EnumSingletonAppMain.main(EnumSingletonAppMain.java:9)

从异常可以看出来，newInstance抛出了异常。推测Java反射是不允许创建Enum对象的，看看源码Constructor.java中的newInstance方法，存在处理Enum类型实例化的一行判断代码

if ((clazz.getModifiers() & Modifier.ENUM) != 0)

满足这个条件就抛出异常。newInstance的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);
       }
   }
   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;
}

原来反射机制不允许实例化Enum类型的对象，自然挡住了反射攻击。

2.避免通过序列化创建单例对象（如果单例类实现了Serializable）（序列化攻击）

/**序列化对象后，如果执行反序列化，也可以创建一个对象。利用此机制来尝试创建一个新的Enum对象
 * 序列化攻击
 * 需要在单例类中增加read
 */
private static void serializableAttack() {
    System.out.println("序列化攻击单例对象-----------开始");
    EnumSingleton singleton = EnumSingleton.getInstance();
    System.out.println(singleton);
    try {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("./EnumSingleton.out"));
        oos.writeObject(singleton);
        ObjectInputStream ois = new ObjectInputStream((new FileInputStream("./EnumSingleton.out")));
        Object obj = ois.readObject(); // 这里利用反序列化创建对象
        System.out.println(obj);
    } catch (IOException e) {
        e.printStackTrace();
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
    System.out.println("序列化攻击单例对象-----------结束");
}

跟踪进入ois.readObject()，会进入ObjectInputStream.readObject0方法。其中会解析class的二进制，根据class的文件定义，分别解析不同类型的字段。重点关注case TC_ENUM如下所示：

switch (tc) {
    case TC_NULL:
        return readNull();
    case TC_REFERENCE:
        return readHandle(unshared);
    case TC_CLASS:
        return readClass(unshared);
    case TC_CLASSDESC:
    case TC_PROXYCLASSDESC:
        return readClassDesc(unshared);
    case TC_STRING:
    case TC_LONGSTRING:
        return checkResolve(readString(unshared));
    case TC_ARRAY:
        return checkResolve(readArray(unshared));
    case TC_ENUM:
        return checkResolve(readEnum(unshared));
    case TC_OBJECT:
        return checkResolve(readOrdinaryObject(unshared));
    case TC_EXCEPTION:
        IOException ex = readFatalException();
        throw new WriteAbortedException("writing aborted", ex);
    case TC_BLOCKDATA:
    case TC_BLOCKDATALONG:
        if (oldMode) {
            bin.setBlockDataMode(true);
            bin.peek();             // force header read
            throw new OptionalDataException(
                bin.currentBlockRemaining());
        } else {
            throw new StreamCorruptedException(
                "unexpected block data");
        }
    case TC_ENDBLOCKDATA:
        if (oldMode) {
            throw new OptionalDataException(true);
        } else {
            throw new StreamCorruptedException(
                "unexpected end of block data");
        }
    default:
        throw new StreamCorruptedException(
            String.format("invalid type code: %02X", tc));
}

进入readEnum方法，重点关注Enum.valueOf方法。如下所示：

/**
 * Reads in and returns enum constant, or null if enum type is
 * unresolvable.  Sets passHandle to enum constant's assigned handle.
 */
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); // 这里根据name和class拿到Enum实例。这里的name="INSTANCE"
            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.valueOf方法。代码如下：

/**
     * Returns the enum constant of the specified enum type with the
     * specified name.  The name must match exactly an identifier used
     * to declare an enum constant in this type.  (Extraneous whitespace
     * characters are not permitted.)
     *
     * <p>Note that for a particular enum type {@code T}, the
     * implicitly declared {@code public static T valueOf(String)}
     * method on that enum may be used instead of this method to map
     * from a name to the corresponding enum constant.  All the
     * constants of an enum type can be obtained by calling the
     * implicit {@code public static T[] values()} method of that
     * type.
     *
     * @param <T> The enum type whose constant is to be returned
     * @param enumType the {@code Class} object of the enum type from which
     *      to return a constant
     * @param name the name of the constant to return
     * @return the enum constant of the specified enum type with the
     *      specified name
     * @throws IllegalArgumentException if the specified enum type has
     *         no constant with the specified name, or the specified
     *         class object does not represent an enum type
     * @throws NullPointerException if {@code enumType} or {@code name}
     *         is null
     * @since 1.5
     */
    public static <T extends Enum<T>> T valueOf(Class<T> enumType,
                                                String name) {
        // 从enumConstantDirectory()中根据name获取对象
        T result = enumType.enumConstantDirectory().get(name);
        if (result != null)
            return result;
        if (name == null)
            throw new NullPointerException("Name is null");
        throw new IllegalArgumentException(
            "No enum constant " + enumType.getCanonicalName() + "." + name);
    }

enumConstantDirectory()是Class的方法，其本质是从Class.java的enumConstantDirectory属性中获取。代码如下：

private volatile transient Map<String, T> enumConstantDirectory = null;

也就是说，Enum中定义的Enum成员值都被缓存在了这个Map中，Key是成员名称（比如“INSTANCE”），Value就是Enum的成员对象。这样的机制天然保证了取到的Enum对象是唯一的。即使是反序列化，也是一样的。

结论

经过上面的分析，枚举的实现天然地支持了单例模式的特点，大大降低了单例的开发难度。