设计模式之单例模式的八种写法

方式一

class Singleton {

    private Singleton() {
    }

    private static final Singleton INSTANCE = new Singleton();

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

总结

• 优点：写法简单，在类装载的时候就完成了实例化，避免了线程同步问题
• 缺点：在类装载的时候就完成了实例化，没有达到 Lazy loading 的效果，如果从始至终从未使用过这个实例，则会造成内存浪费
• 结论：可用，但是可能造成内存浪费
• 扩展：这种方式基于 ClassLoader 机制避免了多线程的同步问题，不过 instance 在类装载的时候就实例化，在单例模式中大多数都是调用 getInstance 方法触发单例类的装载，但是类装载的原因有很多种，因此不能确定有其他方式（或者其他的静态方法）导致类装载，这时候初始化 instance 就没有达到 Lazy loading 的效果。

方式二

class Singleton {

    private static final Singleton INSTANCE;

    static {
        INSTANCE = new Singleton();
    }

    private Singleton() {
    }

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

总结

• 优缺点：与上面的方式类似，只不过将类的实例化过程放到了静态代码块中，也是在类装载的时候就执行静态代码块中的代码，初始化类的实例
• 结论：可用，但是可能造成内存浪费

方式三

class Singleton {

    private static Singleton instance;

    private Singleton() {
    }

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

总结

• 优点：起到了 Lazy loading 的效果，但是只能在单线程下使用
• 缺点：如果在多线程下，一个线程进入了 if (instance == null) {} 判断块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例，所以在多线程环境下不可使用这种方式
• 结论：在实际开发中，不能使用这种方式

方式四

class Singleton {

    private static Singleton instance;

    private Singleton() {
    }

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

总结

• 优点：解决了线程不安全问题
• 缺点：效率太低了，每个线程在获取类的实例的时候，执行 getInstance 方法都需要进行同步，而其实这个方法只需要执行一次实例化代码就够了，后面的想获得该类实例，直接 return 就行了，对方法进行同步效率太低
• 结论：实际开发中，不推荐使用这种方式

方式五

class Singleton {

    private static Singleton instance;

    private Singleton() {
    }

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

总结

• 优点：无
• 缺点：这种方式本意是想对第四种方式进行改进，因为前面的同步方法效率太低，改为同步进行实例化的代码块。但是这种方式并不能起到线程同步的作用，跟第三种实现方式遇到的情形一致，假如一个线程进入了 if (instance == null) {} 判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。
• 结论：实际开发中，不能使用这种方式

方式六

class Singleton {

    // volatile 可以让修改值立即刷新到主存, 可以理解为一个轻量级的 synchronized
    // 同时保证了效率, 推荐使用
    private static volatile Singleton instance;

    private Singleton() {
    }

    // 提供一个静态的公有方法, 加入双重检查代码, 解决线程安全问题, 同时解决懒加载问题
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

总结

• 优点：
  • Double-check 概念是多线程开发中经常使用到的，如代码中所示，我们进行了两次 if (instance == null) 检查，这样就可以保证线程安全了
  • 实例化代码只用执行一次，后面再次访问时，判断 if (instance == null) 后直接 return 实例化对象，也避免了反复进行方法同步
  • 线程安全、延迟加载、效率较高
• 缺点：
• 结论：在实际开发中，推荐使用这种单例设计模式

方式七

class Singleton {

    private Singleton() {
    }

    /**
     * 懒加载 + 线程安全
     * 当 Singleton 进行类装载的时候, 其静态内部类 SingletonInstance 是不会被装载的.
     * JVM 虚拟机在装载类的时候是线程安全的
     * 使用 JVM 底层提供的装载机制保证了这个初始化是线程安全的
     */
    private static class SingletonInstance {
        // final 修饰会在底层进行加优化
        private static final Singleton INSTANCE = new Singleton();
    }

    /**
     * 调用 getInstance 方法时候触发静态内部类的装载,且只会装载一次
     * 类装载时候是线程安全的
     * 子类的 private 属性可以被父类(直接)访问, 父类的不可以被子类(直接)访问
     *
     * @return
     */
    public static Singleton getInstance() {
        return SingletonInstance.INSTANCE;
    }
}

总结

• 优点：
  • 这种方式采用了类装载机制来保证初始化实例时只有一个线程
  • 静态内部类方式在 Singleton 类被装载时并不会立刻实例化，而是在需要实例化时，调用 getInstance 方法，才会装载 SingletonInstance 类，从而完成 Singleton 的实例化
  • 类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM 帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的
  • 避免了线程不安全性，利用静态内部类特点实现了延迟加载，效率高
• 结论：推荐使用

方式八

/**
 * effective java 作者推荐写法
 * 枚举实际上是一个常量类, 也不一定是, 绝大不数情况下是
 * final class cn.yangxianda.design.pattern.singleton.type8.Singleton extends java.lang.Enum<cn.yangxianda.design.pattern.singleton.type8.Singleton>
 * public static final cn.yangxianda.design.pattern.singleton.type8.Singleton INSTANCE;
 */
enum Singleton {
    INSTANCE;

    public void sayOK() {
        System.out.println("ok~");
    }
}

总结

• 优点：
• 借助 JDK 1.5 中添加的枚举来实现单例模式，不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象
• 这种方式是 Effective Java 作者 Josh Bloch 提倡的方式
• 结论：推荐使用
• 扩展：反序列化测试

public class UnserializationTest {

    public static void main(String[] args) throws IOException, ClassNotFoundException {

        Singleton instance = Singleton.INSTANCE;
        Singleton instance2 = Singleton.INSTANCE;
        System.out.println(instance == instance2);

        // 反序列化测试
        unserialize(instance);
    }

    private static void unserialize(Singleton instance) throws IOException, ClassNotFoundException {

        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
        objectOutputStream.writeObject(instance);

        ByteArrayInputStream inputStream = new ByteArrayInputStream(outputStream.toByteArray());
        ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);
        Singleton clone = (Singleton) objectInputStream.readObject();

        System.out.println(instance == clone); // true
        System.out.println(instance.hashCode());
        System.out.println(clone.hashCode());
    }
}

enum Singleton {
    INSTANCE;

    public void sayOK() {
        System.out.println("ok~");
    }
}

推荐的几种方式

• 枚举
• 静态内部类
• Double-check
• 饿汉式（线程安全但是会造成资源浪费）