一、认识

单例模式：Singleton Pattern，属于创建型模式，提供一种创建对象的方式。

1.单例类只能有一个实例

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

3.单例类必须给 其他所有对象 提供这一实例

二、介绍

1.保证一个类仅有一个实例，提供一个访问它的全局访问点。

2.目的：为了节省系统资源、避免一个全局使用的类频繁地创建与销毁

3.应用场景：

一对一的关系

一些设备管理器，例如打印机，我们要避免两台打印机同时打印一份文件，就可以采用单例

4.缺点：

无接口 + 不能继承 + 与单一职责原则冲突(一个类应该只关心内部实现逻辑，而不关心外部怎么来实例化)

5.使用场景：

要求生产唯一的序列号；

Web的技术器，可以先用单例缓存，最后再一次写入db。（解决了每次访问db、节省系统资源）

创建对象需要消耗资源过多(例如I/O 、 与db连接)

 

三、代码实现

一共有6种实现方法：

懒汉式：分为线程安全和不安全，两种；

饿汉式：一种；

双重校验锁：性能高、多线程下。

登记式/静态内部类

枚举

（1）懒汉式

1.线程不安全：

package com.kevin.springbootkevin1.javatest;
/*
* 懒汉式 线程不安全
*
* 是否 Lazy 初始化：是
* 是否多线程安全：否
* 实现难度：易
* 描述：这种方式是最基本的实现方式，这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized，所以严格意义上它并不算单例模式。
* 这种方式 lazy loading 很明显，不要求线程安全，在多线程不能正常工作。
* */
public class SingleObjectLazyUnsafe {
    private static SingleObjectLazyUnsafe singleObjectLazyUnsafe;   //这里先不实例化   懒汉式

    private SingleObjectLazyUnsafe(){}

    public static SingleObjectLazyUnsafe  getInstance(){
        if(singleObjectLazyUnsafe == null) {
            singleObjectLazyUnsafe = new SingleObjectLazyUnsafe();     //线程不安全
        }
        return singleObjectLazyUnsafe;
    }
}

2.线程安全：

提供一个全局访问点-提供一个方法，获取到该类的唯一实例。在方法体上加锁 关键字(synchronized)。

缺点：加锁，影响效率。因为大多数情况下不需要同步。

package com.kevin.springbootkevin1.javatest;
/*
* 懒汉式 线程安全
*
* 是否 Lazy 初始化：是
* 是否多线程安全：是
* 实现难度：易
* 描述：这种方式具备很好的 lazy loading，能够在多线程中很好的工作，但是，效率很低，99% 情况下不需要同步。
* 优点：第一次调用才初始化，避免内存浪费。
* 缺点：必须加锁 synchronized 才能保证单例，但加锁会影响效率。
* getInstance() 的性能对应用程序不是很关键（该方法使用不太频繁）。
* */
public class SingleObjectLazySafe {
    private static SingleObjectLazySafe singleObjectLazySafe;

    private SingleObjectLazySafe(){}

    //synchronized-加锁,保证线程安全
    public static synchronized SingleObjectLazySafe  getInstance(){      //线程安全
        if(singleObjectLazySafe == null) {
            singleObjectLazySafe = new SingleObjectLazySafe();
        }
        return singleObjectLazySafe;
    }
}

（2）饿汉式：

执行效率不错。

缺点：类加载时就初始化，浪费内存资源。

package com.kevin.springbootkevin1.javatest;
/*
* 饿汉式单例
*
* 是否 Lazy 初始化：否
* 是否多线程安全：是
* 实现难度：易
* 描述：这种方式比较常用，但容易产生垃圾对象。
* 优点：没有加锁，执行效率会提高。
* 缺点：类加载时就初始化，浪费内存。
* 它基于 classloader 机制避免了多线程的同步问题， 不过，instance 在类装载时就实例化，
* 虽然导致类装载的原因有很多种，在单例模式中大多数都是调用 getInstance 方法，
* 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，
* 这时候初始化 instance 显然没有达到 lazy loading 的效果。
* * */
public class SingleObjectHungrySafe {
    //类装载就实例化,但容易生成垃圾对象
    private static SingleObjectHungrySafe singleObjectHungrySafe = new SingleObjectHungrySafe();

    private SingleObjectHungrySafe(){}

    public static SingleObjectHungrySafe getInstance() {
        return singleObjectHungrySafe;
    }
}

（3）双重校验锁     DCL     double-checked locking

我个人觉得最好的方式....支持多线程、高性能

package com.kevin.springbootkevin1.javatest;

/*
* 双重锁单例
*
* JDK 版本：JDK1.5 起
* 是否 Lazy 初始化：是
* 是否多线程安全：是
* 实现难度：较复杂
* 描述：这种方式采用双锁机制，安全且在多线程情况下能保持高性能。
* getInstance() 的性能对应用程序很关键。
*/
public class SingleObjectDoubleLock {

    private volatile static SingleObjectDoubleLock singleObjectDoubleLock;
    
    private SingleObjectDoubleLock(){}
    
    public static SingleObjectDoubleLock getInstance() {
        if(singleObjectDoubleLock == null) {
            synchronized (SingleObjectDoubleLock.class) {
                if(singleObjectDoubleLock == null) {
                    singleObjectDoubleLock = new SingleObjectDoubleLock();
                }
            }
        }
        return singleObjectDoubleLock;
    }
}

（4）登记式\静态内部类

package com.kevin.springbootkevin1.javatest;


/*
* 和双重锁一样的功效
* 不同之处： 这种方式适用于 静态域 情况(对静态域使用延迟初始化)。
*           双重锁方式在实例需要延迟初始化时使用
* */
public class SingleStatic {
    /* SingleStatic被装载了, singleStatic都不一定被初始化。
    *  需要SingletonHolder内部类 被主动使用。
    *  只有显示地调用getInstance()方法 ,才会装载SingletonHolder类, 实例化singleStatic
    *  */
    private static class SingletonHolder {
        private static final SingleStatic singleStatic = new SingleStatic();
    }
    
    private SingleStatic(){}

    public static final SingleStatic getInstance() {
        return SingletonHolder.singleStatic;
    }
}

（5）枚举

(涉及到反序列化创建对象时，可采用)

package com.kevin.springbootkevin1.javatest;
/*
* 支持多线程
* 简洁
* 但未被广泛采用
* 自动支持序列化机制
* 
* 防止反序列化重新创建新的对象,绝对防止对此实例化
* */
public enum  SingleEnum {
    Instance;
    public void whateverMethod() {
        
    }
}