【设计模式实践系列】单例模式

单例模式

单例模式，属于创建类型的一种常用的软件设计模式。通过单例模式的方法创建的类在当前进程中只有一个实例。

意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

主要解决：一个全局使用的类频繁地创建与销毁。

何时使用：当您想控制实例数目，节省系统资源的时候。

优点：单例模式会阻止其他对象实例化其自己的单例对象的副本，从而确保所有对象都访问唯一实例。

缺点：没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

懒汉式

使用时才进行创建，有多线程安全问题

/**
 * 懒汉式
 */
public class LazySingleton {

    private static LazySingleton lazySingleton;

    private LazySingleton() {
    }

    public static LazySingleton getInstance() {
        if (lazySingleton == null) {
            lazySingleton = new LazySingleton();
        }
        return lazySingleton;
    }

}

懒汉加锁

保证了线程安全，但是每次获取对象的方法都是通过synchronized实现，会产生上锁、释放锁等额外操作，影响性能。

public class LazySyncSingleton {
    private static LazySyncSingleton lazySingleton;

    private LazySyncSingleton() {
    }

    public static synchronized LazySyncSingleton getInstance() {
        if (lazySingleton == null) {
            lazySingleton = new LazySyncSingleton();
        }
        return lazySingleton;
    }
}

饿汉式

类加载时就进行创建，不存在多线程安全问题，但是浪费内存，延迟启动时间。

public class HungrySingleton {

    private static HungrySingleton hungrySingleton = new HungrySingleton();

    private HungrySingleton() {
    }

    public static HungrySingleton getInstance() {
        return hungrySingleton;
    }

}

双重锁校验

使用时创建，保证多线程安全，避免了懒汉线程安全式的对整个方法加锁的方式，只有在第一次对象还未创建时才会加锁，对象创建以后，每一次获取都不需要了。

public class DoubleCheck {

    private static volatile DoubleCheck doubleCheck;

    private DoubleCheck() {
    }

    public static DoubleCheck getInstance() {
        if (doubleCheck == null) {
            synchronized (DoubleCheck.class) {
                if (doubleCheck == null) {
                    doubleCheck = new DoubleCheck();
                }
            }
        }
        return doubleCheck;
    }

}

静态内部类

对象在静态域中，使用时才进行创建，同时利用ClassLoad机制保证多线程安全问题，比双重锁实现起来更简单一点。

public class StaticSingleton {
    private static class StaticHolder {
        public static final StaticSingleton INSTANCE = new StaticSingleton();
    }

    public static StaticSingleton getInstance() {
        return StaticHolder.INSTANCE;
    }
}

枚举

这种方式是 Effective Java 作者 Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。

public enum EnumSingleton {
    INSTANCE;
}