单例模式（Singleton）

单例模式：保证一个类只有一个实例，并且提供一个可以访问的全局入口。

优点：节省内存、节省计算、方便管理
应用举例：无状态的工具类（日志工具、字符串工具）、全局信息类（全局记数、环境变量）
常见的五种写法：从简单到难递进

饿汉式写法：

优点：类装载的时候就完成了初始化，避免了线程同步的问题。
缺点：从始至终没有使用实例，造成内存浪费。

/**
 * 饿汉式：
 */
public class Singleton {
    private static Singleton singleton = new Singleton();

    private Singleton() {

    }

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

静态代码块：

优点：类装载的时候就完成了初始化，避免了线程同步的问题。同（饿汉式）
缺点：从始至终没有使用实例，造成内存浪费。同（饿汉式）

/**
 * 静态代码块
 */
public class Singleton {
    private static Singleton singleton;

    static {
        singleton = new Singleton();
    }

    private Singleton() {

    }

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

懒汉式：

优点：在getInstance被调用的时候，才实例化对象。
缺点：只能在单线程下使用，多想成环境下，如果一个线程通过 if (singleton == null) {}还没往下执行，另一个线程也通过if (singleton == null) {}这时会多次创建实例。

/**
 * 懒汉式
 */
public class Singleton {
    private static Singleton singleton;

    private Singleton() {

    }

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

线程安全懒汉式：

优点：解决了懒汉式线程安全问题。
缺点：效率太低，多个线程不能同时访问getInstance()方法，不能防止反序列化，生成多个实例。

/**
 * 线程安全懒汉式
 */
public class Singleton {
    private static Singleton singleton;

    private Singleton() {

    }

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

双重检查模式：

优点：实例代码只调用一次，后来判断**if (singleton == null) 只需要判断外层即可跳出，同时线程安全，延迟加载，效率更高。
缺点：效率太低，多个线程不能同时访问getInstance()方法。
1、为什么要判断两次为空？去掉第二层可以吗？
答案：两个线程同时调用getInstance方法，并且singleton为null，两个线程都可以通过第一层为null判断，由于锁机制的存在，一个线程执行完singleton = new Singleton()之后退出synchronized保护区域，如果没有第二层if (singleton == null)判断，第二个线程也会执行singleton = new Singleton()，这样就破坏了单例。
如果去掉第一个 if (singleton == null)所有线程会串行执行，效率低下
2、为什么要加volatile？
答案：singleton = new Singleton()并非原子操作，在JVM中至少做了三件事。
1）给singleton分配内存空间
2）调用Singleton的构造函数来初始化singleton
3）将singleton对象指向分配的内存空间（执行完singleton就不是null了）
存在重排序的优化，可能执行顺序为1）3）2），当执行完3）后对象已经实例化，但并未初始化，其他线程使用该对象就会报错，其他线程使用报错后，对象才被初始化，可是已经晚了。
** volatile可以禁止指令重排，使其按照1）2）3）顺序执行

/**
 * 双重检查模式
 */
public class Singleton {
    private static volatile Singleton singleton;

    private Singleton() {

    }

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

静态内部类的写法：

优点：线程安全，需要实例时才时例化，延迟加载，效率高。
缺点：不能防止反序列化，生成多个实例。

/**
 * 静态内部类
 */
public class Singleton {

    private Singleton() {

    }

    private static class SingletonInstance {
        private static final Singleton singleton = new Singleton();

    }

    public static Singleton getInstance() {
        return SingletonInstance.singleton;
    }
}

枚举式写法

优点：避免多线程同步，JVM保证线程安全（反编译之后看到各个枚举项目通过static来定义和初始化，类加载时被初始化），防止反序列化、反射，破坏单例。其中java还针对枚举类序列化做了规定，仅仅讲枚举类的name属性输出到结果中，反序列化时通过java.lang.Enum的valueof根据名字查找对西那个，而不是新建一个对象。如果反射枚举类会抛出异常。

/**
 * 枚举式
 */
public enum Singleton {
    INSTANCE;

    public void whateverMethod() {
        System.out.println("执行了单例方法，例如返回环境变量信息");

    }

    public static void main(String[] args) {
        //使用枚举写法表示的单例类
        Singleton.INSTANCE.whateverMethod();
    }
}