说明：设计模式根据用途分为创建型、结构性和行为型。创建型模式主要用于描述如何创建对象，本文介绍创建型中的单例模式。

饿汉式单例

单例模式是比较常见的一种设计模式，旨在确保对象的唯一性，什么时候去使用这个对象都是同一个。这样设计的目的是为了避免对象重复创建，浪费资源，同时也保证了对象的唯一性，不至于多个相同的对象，状态不一致的情况。

以下是单例模式的简单实现：

/**
 * 太阳类
 */
public class Sun {
    
    private static final Sun sun = new Sun();

    private Sun() {
    }

    public static Sun getInstance() {
        return sun;
    }
}

需要注意，对象的创建是在对象类内部，且为static final修饰，并且私有化构造方法，使其不能在外部被创建，其次创建一个静态方法，返回其对象；

此时，外部通过类名.方法名的方式，可以访问到该对象，且始终为同一个；

public class Test {
    public static void main(String[] args) {
        Sun sun1 = Sun.getInstance();
        Sun sun2 = Sun.getInstance();
        System.out.println(sun1 == sun2);
    }
}

两次获取到的对象相同

上面这种创建方式，称为饿汉式单例（Eager Singleton），即类加载完成时就创建对象；

懒汉式单例

以下这种方式，称为懒汉式单例（Lazy Singleton），在调用静态方法时才创建对象；

/**
 * 懒汉式单例模式
 */
public class LazySun {
    
    private static LazySun sun = null;

    private LazySun() {
    }

    public static LazySun getInstance() {
        if (sun == null) {
            sun = new LazySun();
        }
        return sun;
    }
}

这种创建方式，可以实现延迟加载，节约资源。但是在多线程并发时，如果有多个线程在if (sun == null)，就会导致对象被创建多次，所以我们很容易想到的是加锁，将静态方法加上锁，如下：

/**
 * 懒汉式单例模式
 */
public class LazySun {

    private static LazySun sun = null;

    private LazySun() {
    }

    public synchronized static LazySun getInstance() {
        if (sun == null) {
            sun = new LazySun();
        }
        return sun;
    }
}

但是，给方法加上锁后，会影响性能，可以考虑减少锁的范围，只锁住创建对象这一行，如下：

/**
 * 懒汉式单例模式
 */
public class LazySun {

    private static LazySun sun = null;

    private LazySun() {
    }

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

双重检查锁定

但是，还有问题。在多线程并发下，如果线程A在创建对象（未完成），线程B、C在if (sun == null) 这里判断为true，即便对象创建完成，线程B、C通过了if判断，也还是会依次再创建对象，也造成了对象被重复创建。因此，还需要改造，如下：

/**
 * 双重检查锁定
 */
public class LazySun {

    private volatile static LazySun sun = null;

    private LazySun() {
    }

    public static LazySun getInstance() {
        // 第一次判断
        if (sun == null) {
            synchronized (LazySun.class) {
                // 第二次判断
                if (sun == null){
                    sun = new LazySun();
                }
            }
        }
        return sun;
    }
}

就是在锁住的代码块里面再进行一次非空判断，称为双重检查锁定（Double-Check Locking），同时，单例对象修饰符加上volatile，确保多个线程都能正确处理；

IoDH

饿汉式单例，是在类被加载时就创建了对象。不需要考虑多线程，但是无论是否使用到对象都创建，造成了资源浪费。而懒汉式单例，虽然做到了延迟加载，但是需要处理好多线程情况下的对象创建，使用了锁，影响了性能。

那有没有一种更好了方式，既能在多线程下使用，又不会影响性能？

在《设计模式的艺术》（刘伟著）中作者提供了一种更好的创建方式，称为IoDH（Initialization on Demand Holder，按需初始化），代码如下：

/**
 * IoDH
 */
public class Singleton {

    private Singleton() {
    }

    private static class HolderClass {
        private final static Singleton instance = new Singleton();
    }

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

这种方式是对饿汉式单例的改进，是在单例类里创建了一个内部类，将单例对象的创建放在了这个内部类里面。因为单例对象不是单例类的一个成员变量，所以对象在类加载时不会被创建，而是会在调用静态方法时被创建，这样既能延迟加载，又没有使用锁，影响性能，一举两得。

书中说，通过使用IoDH，既可以实现延迟加载，又可以保证线程安全，不影响系统性能。因此，IoDH不失为一种最好的Java语言单例模式实现方式；其缺点是与编程语言本身的特性相关，很多面向对象语言不支持IoDH。

总结

本文参考《设计模式的艺术》、《秒懂设计模式》两书