单例模式的几种实现方法

饿汉模式

public class Singleton {
    private static Singleton instance = new Singleton();

    private Singleton() {
    }

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

这种方式非常简单，直接在类加载的时候创建一个实例对象，但是如果没有使用这个实例，就会造成资源浪费。

懒汉模式

容易发现的是饿汉模式是有缺点的，那就是在多线程的情况下，不能保证线程安全，单例唯一。

于是就有了懒汉模式。

public class Singleton {
    private static Singleton instance;

    private Singleton() {
    }

    // synchronized方法,多线程情况下保证单例对象唯一
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

优点： 只有在使用时才会实例化单例，一定程度上节约了资源。（实现懒加载）

缺点： 第一次加载时要立即实例化，反应稍慢。每次调用getInstance()方法都会进行同步，这样会消耗不必要的资源。这种模式一般不建议使用。

DCL模式

我之前一直都是写这种模式的，但是不知道名字，惭愧惭愧。

public class Singleton {
    private static Singleton instance = null;

    private Singleton() {
    }

    public static Singleton getInstance() {
        // 两层判空，第一层是为了避免不必要的同步
        // 第二层是为了在null的情况下创建实例
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }

        }
        return instance;
    }
}

可以发现，这里没有直接上锁，而是在使用时进行判空，这里就避免了同步带来的资源的浪费。

优点： 资源利用率高，既能够在需要的时候才初始化实例，又能保证线程安全，同时调用getInstance()方法不进行同步锁，效率高。

缺点： 第一次加载时稍慢，由于Java内存模型的原因偶尔会失败。在高并发环境下也有一定的缺陷，虽然发生概率很小。

DCL模式是使用最多的单例模式实现方式，除非代码在并发场景比较复杂或者JDK 6以下版本使用，否则，这种方式基本都能满足需求。

静态内部类

public class Singleton {
    private Singleton() {
    }

    public static Singleton getInstance() {
        return SingletonHolder.instance;
    }

    /**
     * 静态内部类
     */
    private static class SingletonHolder {
        private static Singleton instance = new Singleton();
    }
}

仔细观察，你会发现没有synchronized！但是这也可以保证线程安全，是不是很神奇，其实原因就是类只会加载一次，解释如下，第一次调用getInstance方法时，会对Singleton进行加载，此时SingletonHolder并不会被加载，原因是SingletonHolder是相对Singleton独立的，它同样只有在被调用的时候才会被加载。getInstance方法被调用后，会调用SingletonHolder.instance，显然此时SingletonHolder被加载，同时其内部静态属性会被初始化。所以最终会返回一个Singleton实例，当再次执行时此时SingletonHolder不会被加载，也就不会有new Singleton()的过程。

枚举单例

public enum SingletonEnum {
    INSTANCE;
    public void doSomething() {
        System.out.println("do something");
    }
}

这是线程安全的，且非常简单。

容器实现单例

import java.util.HashMap;
import java.util.Map;
/**
 * 容器类实现单例模式
 */
public class SingletonManager {
    private static Map<String, Object> objMap = new HashMap<String, Object>();

    public static void regsiterService(String key, Object instance) {
        if (!objMap.containsKey(key)) {
            objMap.put(key, instance);
        }
    }

    public static Object getService(String key) {
        return objMap.get(key);
    }
}

SingletonManager可以管理多个单例类型，使用时根据key获取对象对应类型的对象。这种方式可以通过统一的接口获取操作，隐藏了具体实现，降低了耦合度。（可以看成单例集合）。