单例模式

在计算机系统中，还有 Windows中任务管理器、回收站、操作系统中的文件系统、多线程中的线程池、显卡的驱动程序对象、打印机的后台处理服务、应用程序的日志对象、数据库的连接池、网站的计数器、Web应用的配置对象、应用程序中的对话框、系统中的缓存等常常被设计成单例。另外，Servlet中Application也采用了单例模式，此外Spring中，每个Bean默认都是单例的，这样便于Spring容器进行管理。

特点

1、单例类只有一个实例对象；
2、该单例对象必须由单例类自行创建；
3、单例类对外提供一个访问该单例的全局访问点；

优缺点

优点

由于单例模式只生成了一个实例，所以能够节约系统资源，减少性能开销，提高系统效率，同时也能够严格控制客户对它的访问。

缺点

单例模式的缺点也正是因为系统中只有一个实例，这样就导致了单例类的职责过重，违背了“单一职责原则”，同时也没有抽象类，这样扩展起来有一定的困难。不适用于变化频繁的对象；滥用单例将带来一些负面问题，如为了节省资源将数据库连接池对象设计为的单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出。如果实例化的对象长时间不被利用，系统会认为该对象是垃圾而被回收，这可能会导致对象状态的丢失；

实现方式

1、饿汉式

该模式能简单快速的创建一个单例对象，而且是线程安全的(只在类加载时才会初始化，以后都不会)。但它有一个缺点，就是不管你要不要都会直接创建一个对象，会消耗一定的性能(当然很小很小，几乎可以忽略不计，所以这种模式在很多场合十分常用而且十分简单)。即不管有没有调用getInstance()方法,都会预先在系统中创建一个静态对象，在多线程模式下是安全的，但是若没有调用方法前就被加载，会占用内存。

HungrySingleton.java

package pattern.singleton.hungrysingleton;

/**
 * 〈一句话功能简述〉饿汉式单例模式:<br>
 * 〈功能详细描述〉
 *
 * @author 刘斌
 * @date 2020/3/1
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
public class HungrySingleton {
    /**
     * 跟懒汉式的区别:直接创建对象
     */
    private static HungrySingleton INSTANCE = new HungrySingleton();

    private HungrySingleton() {
    }

    public static HungrySingleton getInstance() {
        return INSTANCE;
    }
}

HungrySingletonDemo.java

package pattern.singleton.hungrysingleton;

/**
 * 〈一句话功能简述〉饿汉式单例模式客户端调用:<br>
 * 〈功能详细描述〉
 *
 * @author 刘斌
 * @date 2019/3/1
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
public class HungrySingletonDemo {
    public static void main(String[] args) {
        HungrySingleton hungrySingleton1 = HungrySingleton.getInstance();
        HungrySingleton hungrySingleton2 = HungrySingleton.getInstance();
        System.out.println(hungrySingleton1);
        System.out.println(hungrySingleton2);
        //==是判断两个变量或者实例是不是指向同一个内存空间
        System.out.println(hungrySingleton1 == hungrySingleton2);
        //equals是判断两个变量或者实例指向同一个内存空间的值是不是相同
        System.out.println(hungrySingleton1.equals(hungrySingleton2));
        /**
         * 通俗的来说，==是判断两个人是不是住在同一个地址，而equals是判断同一个地址里住的人是不是同一个。
         * 由equals的源码可以看出这里定义的equals与==是等效的（Object类中的equals没什么区别，
         * 不同的原因就在于有些类（像String、Integer等类）对equals进行了重写，
         * 但是没有对equals进行重写的类（比如我们自己写的类）就只能从Object类中继承equals方法，
         *  除非我们在此类中重写equals方法，这样equals方法与==就也是等效的。
         */
    }
}

饿汉式-控制台输出

2、懒汉式

懒汉式:非线程安全

懒汉式单例模式:不会预先创建对象，只有调用方法才创建对象，不会占用内存，在多线程模式下不安全。

LazySingletonFirst.java

package pattern.singleton.lazysingleton;

/**
 * 〈一句话功能简述〉懒汉式单例模式:非线程安全<br>
 * 懒汉式单例模式:不会预先创建对象，只有调用方法才创建对象，不会占用内存，在多线程模式下不安全
 * 〈功能详细描述〉
 *
 * @author 刘斌
 * @date 2020/3/1
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
public class LazySingletonFirst {
    private static LazySingletonFirst INSTANCE;

    //私有化构造函数
    private LazySingletonFirst() {
    }

    //对外提供一个共有静态方法返回单例实例
    public static LazySingletonFirst getInstance() {
        if (null == INSTANCE) {
            INSTANCE = new LazySingletonFirst();
        }
        return INSTANCE;
    }
}

LazySingletonFirstDemo.java

package pattern.singleton.lazysingleton;

/**
 * 〈一句话功能简述〉懒汉式单例模式:非线程安全客户端调用<br>
 * 〈功能详细描述〉
 *
 * @author 刘斌
 * @date 2020/3/1
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
public class LazySingletonFirstDemo {
    public static void main(String[] args) {
        System.out.println(LazySingletonFirst.getInstance());
        System.out.println(LazySingletonFirst.getInstance());
    }
}

懒汉式非线程安全-控制台输出

##############################################

懒汉式:线程安全

LazySingletonSecond.java

package pattern.singleton.lazysingleton;

/**
 * 〈一句话功能简述〉懒汉式单例模式:线程安全<br>
 * 〈功能详细描述〉
 *
 * @author 刘斌
 * @date 2020/3/1
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
public class LazySingletonSecond {

    private static LazySingletonSecond INSTANCE;

    private LazySingletonSecond() {

    }

    /**
     * 定义一个方法来为客户端提供类实例
     */
    public static synchronized LazySingletonSecond getInstance() {
        if (INSTANCE == null) {
            INSTANCE = new LazySingletonSecond();
        }
        return INSTANCE;
    }
}

LazySingletonSecondDemo.java

package pattern.singleton.lazysingleton;

/**
 * 〈一句话功能简述〉懒汉式单例模式:线程安全客户端调用<br>
 * 〈功能详细描述〉
 *
 * @author 刘斌
 * @date 2020/3/1
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
public class LazySingletonSecondDemo {
    public static void main(String[] args) {
        System.out.println(LazySingletonSecond.getInstance());
        System.out.println(LazySingletonSecond.getInstance());
    }
}

懒汉式线程安全-控制台输出

3、静态内部类方式

StaticInnerSingleton.java

package pattern.singleton.staticsingleton;

/**
 * 〈一句话功能简述〉静态内部类单例模式<br>
 * 〈功能详细描述〉
 *
 * @author 刘斌
 * @date 2019/3/1
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
public class StaticInnerSingleton {
    //私有化构造函数
    private StaticInnerSingleton() {
    }

    //定义静态内部类
    private static class Inner {
        private static final StaticInnerSingleton INSTANCE = new StaticInnerSingleton();
    }

    //定义一个静态方法用于对外方法单例实例
    public static StaticInnerSingleton getInstance() {
        return Inner.INSTANCE;
    }
}

StaticInnerSingletonDemo.java

package pattern.singleton.staticsingleton;

/**
 * 〈一句话功能简述〉静态内部类单例模式客户端调用<br>
 * 〈功能详细描述〉
 *
 * @author 刘斌
 * @date 2020/3/1
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
public class StaticInnerSingletonDemo {
    public static void main(String[] args) {
        System.out.println(StaticInnerSingleton.getInstance());
        System.out.println(StaticInnerSingleton.getInstance());
    }
}

静态内部类单例模式-控制台输出

4、双重校验锁单例模式

DoubleCheckSingleton.java

package pattern.singleton.doublecheck;

/**
 * 〈一句话功能简述〉双重检验锁单例模式:<br>
 * 〈功能详细描述〉https://www.jianshu.com/p/71b85a15e6a2
 *
 * @author 刘斌
 * @date 2020/3/1
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
public class DoubleCheckSingleton {
    /**
     * 第二层锁，volatile关键字禁止指令重排
     */
    private static volatile DoubleCheckSingleton INSTANCE;

    private DoubleCheckSingleton() {

    }

    public static DoubleCheckSingleton getInstance() {
        if (null == INSTANCE) {//第一层检查，检查是否有引用指向对象，高并发情况下会有多个线程同时进入

            synchronized (DoubleCheckSingleton.class) {
                //第一层锁，保证只有一个线程进入
                //双重检查，防止多个线程同时进入第一层检查(因单例模式只允许存在一个对象，故在创建对象之前无引用指向对象，所有线程均可进入第一层检查)
                //当某一线程获得锁创建一个Singleton对象时,即已有引用指向对象，singleton不为空，从而保证只会创建一个对象
                //假设没有第二层检查，那么第一个线程创建完对象释放锁后，后面进入对象也会创建对象，会产生多个对象

                if (INSTANCE == null) {//第二层检查
                    //volatile关键字作用为禁止指令重排，保证返回Singleton对象一定在创建对象后
                    INSTANCE = new DoubleCheckSingleton();
                    //singleton=new Singleton语句为非原子性，实际上会执行以下内容：
                    //(1)在堆上开辟空间；(2)属性初始化;(3)引用指向对象
                    //假设以上三个内容为三条单独指令，因指令重排可能会导致执行顺序为1->3->2(正常为1->2->3),
                    // 当单例模式中存在普通变量需要在构造方法中进行初始化操作时，单线程情况下，顺序重排没有影响；
                    // 但在多线程情况下，假如线程1执行singleton=new Singleton()语句时先1再3，由于系统调度线程2的原因没来得及执行步骤2，
                    // 但此时已有引用指向对象也就是singleton!=null，故线程2在第一次检查时不满足条件直接返回singleton，此时singleton为null(即str值为null)
                    //volatile关键字可保证singleton=new Singleton()语句执行顺序为123，因其为非原子性依旧可能存在系统调度问题(即执行步骤时被打断)，
                    // 但能确保的是只要singleton!=0，就表明一定执行了属性初始化操作；
                    // 而若在步骤3之前被打断，此时singleton依旧为null，其他线程可进入第一层检查向下执行创建对象
                }
            }
        }
        return INSTANCE;
    }
}

5、枚举单例模式

内部枚举类形式

EnumSingletonFirst.java

package pattern.singleton.enumsingleton;

/**
 * 〈一句话功能简述〉枚举单例模式:内部枚举类形式:构造方法中实例化对象<br>
 * 〈功能详细描述〉https://www.jianshu.com/p/71b85a15e6a2
 *
 * @author 刘斌
 * @date 2020/3/1
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
public class EnumSingletonFirst {
    /**
     * 私有化构造函数
     */
    private EnumSingletonFirst() {
    }

    /**
     * 对外暴露一个获取enumSingleton对象的静态方法
     *
     * @return EnumSingletonFirst
     */
    public static EnumSingletonFirst getInstance() {
        return SingletonEnum.INSTANCE.getInstnce();
    }

    /**
     * 定义一个静态枚举类
     */
    enum SingletonEnum {
        //创建一个枚举对象，该对象天生为单例
        INSTANCE;
        private EnumSingletonFirst enumSingletonFirst;

        /**
         * 私有化枚举的构造函数,JVM会保证此方法绝对只调用一次
         */
        private SingletonEnum() {
            enumSingletonFirst = new EnumSingletonFirst();
        }

        public EnumSingletonFirst getInstnce() {
            return enumSingletonFirst;
        }
    }
}

EnumSingletonFirstDemo.java

package pattern.singleton.enumsingleton;

/**
 * 〈一句话功能简述〉枚举单例模式:内部枚举类形式客户端调用<br>
 * 〈功能详细描述〉
 *
 * @author 刘斌
 * @date 2020/3/1
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
public class EnumSingletonFirstDemo {

    public static void main(String [] args){
        System.out.println(EnumSingletonFirst.getInstance());
        System.out.println(EnumSingletonFirst.getInstance());
        System.out.println(EnumSingletonFirst.getInstance()== EnumSingletonFirst.getInstance());
    }
}

内部枚举类形式单例模式-控制台输出

##############################################

单例模式内部枚举类形式二

EnumSingletonSecond.java

package pattern.singleton.enumsingleton;

/**
 * 〈一句话功能简述〉枚举单例模式:内部枚举类形式:枚举常量的值即为对象实例<br>
 * 〈功能详细描述〉
 *
 * @author 刘斌
 * @date 2020/3/1
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
public class EnumSingletonSecond {
    private EnumSingletonSecond(){}
    public static EnumSingletonSecond getInstance(){
        return Singleton.INSTANCE.getInstance();
    }

    /**
     * 内部枚举类形式:枚举常量的值即为对象实例
     */
    private enum Singleton{
        /**
         * 枚举常量的值即为对象实例
         */
        INSTANCE(new EnumSingletonSecond());
        private EnumSingletonSecond singleton;

        /**
         * JVM会保证此方法绝对只调用一次
         * @param singleton 对象实例
         */
        Singleton(EnumSingletonSecond singleton){
            this.singleton = singleton;
        }
        public EnumSingletonSecond getInstance(){
            return singleton;
        }
    }
}

##############################################

单例模式内部枚举类形式三

EnumSingletonThird.java

package pattern.singleton.enumsingleton;

/**
 * 〈一句话功能简述〉枚举单例模式<br>
 * 〈功能详细描述〉
 *
 * @author 刘斌
 * @date 2020/3/1
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
public enum EnumSingletonThird {

    //定义两个实例，一个表示请求成功，一个表示请求失败
    HTTP_200(200,"请求成功"), HTTP_500(500,"请求失败");

    //枚举和普通的类一样，可以定义属性，构造函数，getter setter，普通方法，
    private Integer code;
    private String msg;

   private EnumSingletonThird(Integer code, String msg) {
        this.code = code;
        this.msg = msg;
    }

    public Integer getCode() {
        return code;
    }

    public String getMsg() {
        return msg;
    }
}

EnumSingletonThirdDemo.java

package pattern.singleton.enumsingleton;
/**
 * 〈一句话功能简述〉枚举单例模式方式三，客户端调用<br>
 * 〈功能详细描述〉
 *
 * @author 刘斌
 * @date 2020/3/1
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
public class EnumSingletonThirdDemo {
    public static void main(String [] args){
        System.out.println(EnumSingletonThird.HTTP_200);
        System.out.println(EnumSingletonThird.HTTP_500);
        System.out.println(EnumSingletonThird.HTTP_200== EnumSingletonThird.HTTP_200);
        System.out.println(EnumSingletonThird.HTTP_200.equals(EnumSingletonThird.HTTP_200));
        System.out.println(EnumSingletonThird.HTTP_200.getMsg());
        System.out.println(EnumSingletonThird.HTTP_500);
        System.out.println(EnumSingletonThird.HTTP_500.getCode());
    }
}

内部枚举类形式三控制台输出

##############################################

接口实现形式

IEnumSingletonFourth.java

package pattern.singleton.enumsingleton;

/**
 * 〈一句话功能简述〉枚举单例模式:接口实现形式<br>
 * 〈功能详细描述〉
 *
 * @author 刘斌
 * @date 2020/3/1
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
public interface IEnumSingletonFourth {
    void doSomething1();
    void doSomething2();
    void doSomething3(String args);
}

ImplEnumSingletonFourth.java

package pattern.singleton.enumsingleton;

/**
 * 〈一句话功能简述〉枚举单例模式:接口实现形式<br>
 * 〈功能详细描述〉
 *
 * @author 刘斌
 * @date 2020/3/1
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
public enum ImplEnumSingletonFourth implements IEnumSingletonFourth {
    /**
     * 枚举单例模式:接口实现形式
     */
    INSTANCE {
        @Override
        public void doSomething1() {
            System.out.println("complete singleton1");
        }

        @Override
        public void doSomething2() {
            System.out.println("complete singleton2");
        }

        @Override
        public void doSomething3(String args) {
            System.out.println("complete singleton3,args={"+args+"}");
        }
    };
    public static IEnumSingletonFourth getInstance() {
        return ImplEnumSingletonFourth.INSTANCE;
    }
}

IEnumSingletonFourthDemo.java

package pattern.singleton.enumsingleton;
/**
 * 〈一句话功能简述〉枚举单例模式-接口实现形式：客户端调用<br>
 * 〈功能详细描述〉
 *
 * @author 刘斌
 * @date 2020/3/1
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
public class IEnumSingletonFourthDemo {
    public static void main(String [] args){
        ImplEnumSingletonFourth.getInstance().doSomething1();
        ImplEnumSingletonFourth.getInstance().doSomething2();
        ImplEnumSingletonFourth.getInstance().doSomething3("demo");
    }
}