单例模式【1】——饿汉与懒汉

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

单例模式的特点：
1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。

单例模式分为饿汉式（2种）和懒汉式（3种），双重检查，静态内部类和枚举
饿汉式单例模式无论你使用了这个对象没有，他都会将这个对象实例化
懒汉式就类似于懒加载，当你用到它的时候才会实例化，没有用到的时候是没有实例化的，懒汉式又可以分为线程安全的和非线程安全的，详情直接见代码。

/**
 * 饿汉式（静态常量）
 * 优点：写法比较简单，在类装载的时候就完成实例化。避免了线程同步问题
 * 缺点：在类装载的时候就完成实例化，没有达到懒加载的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费
 * 结论：可用，但可能造成内存浪费
 */
public class Singleton1 {
    /**
     * 1. 在本类内部私有化创建实例对象
     */
    private final static Singleton1 SINGLETON_1 = new Singleton1();

    /**
     * 2. 私有化构造器 外部不能new
     */
    private Singleton1() {

    }

    /**
     * 3.提供一个公有的静态访问 供外部获取实例对象
     */
    public static Singleton1 getInstance() {
        return SINGLETON_1;
    }
}

/**
 * 饿汉式（静态代码块）
 * 这种方式和静态代码块的方式是类似的，只不过将类实例化的过程放在了静态代码块中，
 * 也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例。优缺点是一样的。
 * 结论：可用，但可能造成内存浪费
 */
public class Singleton2 {
    /**
     * 1. 在本类内部私有化创建实例对象
     */
    private final static Singleton2 SINGLETON_1;

    /**
     * 静态代码看中初始化实例对象
     */
    static {
        SINGLETON_1 = new Singleton2();
    }

    /**
     * 2. 私有化构造器 外部不能new
     */
    private Singleton2() {

    }

    /**
     * 3.提供一个公有的静态访问 供外部获取实例对象
     */
    public static Singleton2 getInstance() {
        return SINGLETON_1;
    }
}

饿汉式单例：

/**
 * 懒汉式（线程不安全）
 * 起到了懒加载的效果，但是只能在单线程下使用。
 * 如果在多线程下，一个线程进入了 if判断语句块，还未来得及往下执行，
 * 另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式
 * 结论：在实际开发中，不要使用这种方式
 */
public class Singleton3 {
    /**
     * 1. 在本类内部私有化创建实例对象
     */
    private static Singleton3 SINGLETON_1;

    /**
     * 2. 私有化构造器 外部不能new
     */
    private Singleton3() {

    }

    /**
     * 3.提供一个公有的静态访问 当使用到时才去创建实例对象，供外部获取实例对象 即懒汉式
     */
    public static Singleton3 getInstance() {
        if (SINGLETON_1 == null) {
            SINGLETON_1 = new Singleton3();
        }
        return SINGLETON_1;
    }
}

/**
 * 懒汉式（线程安全）
 * 解决了线程安全问题
 * 效率太低了，每个线程在想获得类的实例时候，执行getInstance()方法都要进行同步。
 * 而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接return就行了。方法进行同步效率太低
 * 结论：在实际开发中，不推荐使用这种方式
 */
public class Singleton4 {
    /**
     * 1. 在本类内部私有化创建实例对象
     */
    private static Singleton4 SINGLETON_1;

    /**
     * 2. 私有化构造器 外部不能new
     */
    private Singleton4() {

    }

    /**
     * 3.提供一个公有的静态访问 加入同步处理 解决线程安全问题
     * 当使用到时才去创建实例对象，供外部获取实例对象 即懒汉式
     */
    public static synchronized Singleton4 getInstance() {
        if (SINGLETON_1 == null) {
            SINGLETON_1 = new Singleton4();
        }
        return SINGLETON_1;
    }
}

/**
 * 懒汉式（线程安全,同步代码块）
 * 本意是在上一个写法的基础上提高效率，但是又回到了第三种写法上，当两个线程都进入if判断中，
 * 会产生多个实例，并未解决线程安全点饿问题
 * 结论：在实际开发中，不能使用这种方式
 */
public class Singleton5 {
    /**
     * 1. 在本类内部私有化创建实例对象
     */
    private static Singleton5 SINGLETON_1;

    /**
     * 2. 私有化构造器 外部不能new
     */
    private Singleton5() {

    }

    /**
     * 3.提供一个公有的静态访问 加入同步处理 解决线程安全问题
     * 当使用到时才去创建实例对象，供外部获取实例对象 即懒汉式
     */
    public static Singleton5 getInstance() {
        if (SINGLETON_1 == null) {
            synchronized(Singleton5.class) {
                SINGLETON_1 = new Singleton5();
            }
        }
        return SINGLETON_1;
    }
}