单例设计模式的四种实现方式

单例设计模式的三个要求：

1. 只能有一个实例

2. 必须自行创建自己的唯一实例

3. 要对外提供该实例

方法一：饿汉式

直接创建实例对象，不管你是否需要这个对象都会去创建

/** 
 * 方法一
 * 单例模式的实现：饿汉式,线程安全 但效率比较低 
 */ 
public class Singleton1 {
    // 自行创建自己的唯一实例
    private static final Singleton1 instance = new Singleton1();

    // 构造器私有化
    private Singleton1() {
    }

    // 提供对外使用的唯一实例
    public static Singleton1 getInstance() {
        return instance;
    }
}

饿汉式的优缺点：

优点：写起来简单，没有线程同步问题。

缺点：当类Singleton1被加载的时候，会初始化static的instance，静态变量被创建并分配内存空间，从这以后，这个static的instance对象便一直占着这段内存（即便你还没有用到这个实例），当类被卸载时，静态变量被摧毁，并释放所占有的内存，因此在某些特定条件下会耗费内存。

方法二：懒汉式

类加载时没有创建实例，使用时才会去创建该对象，延迟加载

public class Singleton2 {
    // 注意，这里没有被final修饰
    private static Singleton2 instance;

    // 私有的构造方法
    private Singleton2() {
    }

    // 调用实例化方法时才会创建该对象
    public static Singleton2 getInstance() {
        // 当该实例不存在时才会创建
        if (instance == null) {
            instance = new Singleton2();
        }
        return instance;
    }
}

懒汉式的优缺点：

优点：写起来简单，类加载时没有创建实例，只有调用实例化方法时才创建实例，特定条件下节约了内存

缺点：并发环境下可能出现多个实例

方法三：线程安全的懒汉式

public class Singleton3 {
    // 将自身实例化对象设置为一个属性，并用static修饰
    private static Singleton3 instance;

    // 私有构造方法
    private Singleton3() {
    }

    // 使用synchronized修饰保证线程安全
    public static synchronized Singleton3 getInstance() {
        if (instance == null) {
            instance = new Singleton3();
        }
        return instance;
    }
}

线程安全的懒汉式优缺点：

优点：多线程环境下，保证了懒汉式的线程安全

缺点：synchronized在多线程环境下效率低下，不是最佳实现

方法四：DCL双重检查锁机制 (DCL：double checked locking)

public class Singleton4 {
    // 将自身实例化对象设置为一个属性，并用static修饰
    private static Singleton4 instance;

    // 私有化构造方法
    private Singleton4() {
    }

    // 静态方法返回该实例
    public static Singleton4 getInstance() {
        // 第一次检查instance是否被实例化
        if (instance == null) {
            // 同步代码块（对象未初始化时，使用同步代码块，保证多线程访问时对象在第一次创建后，不再重复被创建）
            synchronized (Singleton4.class) {
                // 第二次检查instance是否被实例化
                if (instance == null) {
                    instance = new Singleton4();
                }
            }
        }
        return instance;
    }
}

DCL双重检查锁机制是单例模式的最佳实现，内存占用低，效率高，线程安全，多线程操作保证原子性。