单例
 
 
 
Singleton类被称为单例类,通过使用private的构造函数确保了在一个应用只产生一个实例.
 
 
----设计模式之禅
 
 
使用场景
 
 
 
在一个系统中,要求一个类有且仅有一个对象,如果出现多个对象就会出现"不良反应",可以采用单例模式,
 
 
具体使用场景如下:
 
 
需要生成唯一序列号的环境
创建一个对象需要消耗的资源过多,如要访问IO和数据库等资源.
等等
 
 
单例的逐渐进化之路
 
1.饿汉式
 
/**
 * can't lazy load
 * 饿汉式,不能懒加载
 * @author husky
 * @date 2019/5/3 20:42
 */
public class SingletonObject1 {
    private static final SingletonObject1 instance = new SingletonObject1();

    private SingletonObject1(){
        //empty
    }

    private static SingletonObject1 getInstance(){
        return instance;
    }

}

 
2.懒汉式
 
/**
 * 在多线程情况下是不安全的,因为在getIntsance中判断的时候,可能会造成多个实例出现
 * 实现懒加载,但线程不安全
 * @author husky
 * @date 2019/5/3 21:02
 */
public class SingletonObject2 {
    private static SingletonObject2 instance;

    private SingletonObject2(){
        //empty
    }

    public static SingletonObject2 getInstance(){
        if(null == instance){
            instance = new SingletonObject2();
        }
        return instance;
    }
}
 
3.线程安全懒汉式
 
/**
 * 加一把锁可以解决,这把锁是class锁,SingletonObject3.class
 * 但是会造成效率低下
 * 实现了线程安全,但性能不高
 * @author husky
 * @date 2019/5/3 21:08
 */
public class SingletonObject3 {
    private static SingletonObject3 instance;

    private SingletonObject3(){
        //empty
    }

    public synchronized static SingletonObject3 getInstance(){
        if(null == instance){
            instance = new SingletonObject3();
        }
        return instance;
    }
}
 
4.double-check
 
/**
 * double check
 * 解决了懒加载以及单例,以及性能问题,但是有问题,可能会出现空指针异常
 * 在private SingletonObject()会造成fielda或者fieldB未被赋值,导致空指针
 * @author husky
 * @date 2019/5/3 21:31
 */
public class SingletonObject4 {
    private static SingletonObject4 instance;
    private int fieldA;
    private int fieldB;

    private SingletonObject4(){
        fieldA = Integer.MIN_VALUE;
        fieldB = Integer.MAX_VALUE;
    }

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

}

 
此处出现的空指针异常,具体原因可以查看 double-check出现的错误
 
5.double-check volatile
 
/**
 *
 * 加入volatile可以避免空指针异常,也就是dcl,但是效率有点低
 * @author husky
 * @date 2019/5/3 23:12
 */
public class SingletonObject5 {
    private static volatile  SingletonObject5 instance;

    private SingletonObject5(){

    }

    private static SingletonObject5 getInstance(){
        if(null == instance){
            synchronized (SingletonObject5.class){
                if(null == instance){
                    return new SingletonObject5();
                }
            }
        }
        return instance;
    }
}
 
6.静态内部类
 
public class SingletonObject6 {

    private SingletonObject6(){

    }

    private static class InstanceHolder {
        private final static SingletonObject6 instance = new SingletonObject6();
    }

    public static SingletonObject6 getInstance(){
        return InstanceHolder.instance;
    }
}
 
7.枚举,推荐使用6或7,关于枚举,会在后面博客当中进行分析
 
import java.util.stream.IntStream;

/**
 * 枚举类型
 * @author husky
 * @date 2019/5/4 14:37
 */
public class SingletonObject7 {
    private SingletonObject7(){

    }

    private enum Singleton {
        /**
         * instance
         * */
        INSTANCE;
        private final SingletonObject7 instance;

        Singleton(){
            instance = new SingletonObject7();
        }

        public SingletonObject7 getInstance(){
            return instance;
        }
    }

    public static SingletonObject7 getInstance(){
        return Singleton.INSTANCE.getInstance();
    }

    public static void main(String[] args) {
        IntStream.rangeClosed(1,50).forEach(i->{
            new Thread(String.valueOf(i)){
                @Override
                public void run() {
                    System.out.println(SingletonObject7.getInstance());
                }
            }.start();
        });
    }


}

1. 单例模式的实现方式1：
 
package com.object;
 
public class Singleton1 {
 
    private static final Singleton1 INSTANCE = new Singleton1();
     
     private Singleton1() { }
     
     public static Singleton1 getInstance() {
         return INSTANCE;
     }
 
}
 2. 单例模式的实现方式2：
 
package com.object;
 
public class Singleton2 {
 
    private static Singleton2 instance = null;
     
     private Singleton2() { }
     
     public static synchronized Singleton2 getInstance() {
         if (instance == null) {
             instance = new Singleton2();
         }
         return instance;
     }
 
}
 
3. 单例模式的实现方式3：
 
package com.object;
 
public class Singleton3 {
 
    private static Singleton3 instance = null;
     
     private Singleton3() { }
     
     public static Singleton3 getInstance() {
         if (instance == null) {
             synchronized(Singleton3.class) {
                 if (instance == null) {
                     instance = new Singleton3();
                 }
             }
         }
         return instance;
     }
 
}
 
4. 单例模式的实现方式4：
 
package com.object;
 
public class Singleton4 {
     
     private static class SingletonHolder {
         private static final Singleton4 INSTANCE = new Singleton4();
     }
 
    private Singleton4() { }
     
     public static Singleton4 getInstance() {
         return SingletonHolder.INSTANCE;
     }
 
}
  

前言
 
好久没写东西了，但是想着无论什么事还是要坚持自己初心要坚持的东西。写东西不能断！
 
对于常用的23种设计模式，这里笔者会根据自己学习和出现频率、重要程度进行学习记录吧。并且每种设计模式可能会根据暂时需求侧重学习深浅。
 
单例模式
 
 
 
有很多直接把单例分成很多种，这里我就分两个大类(饿汉懒汉)在这里说啦。
 
 
单例模式（Singleton Pattern）是设计模式中最简单的模式之一，属于创建型模式。这种设计模式主要是类的对象只有一个实例，不需要每次new 创造。而我们要做的的就是确保这个对象创建的唯一。然后根据一些特征进行优化创建以及访问改类。
 
而单例模式也有很多的应用，比如很多驱动例如摄像头、打印机等等，而在javaweb中的spring有很多配置文件，掌控全局，同样也是单例的。
 
 
 
对于单例，主要是全局只有这么一个对象。对了它的理解，这里笔者打几个有可能不太恰当的理解，目的在于帮助理解记忆，如果有错误还请指正。
 
 
个人可能不太恰当的理解：
 
一定程度上单例模式和普通的模式有可能是一根根火柴和打火机的差别。火柴想燃烧每次都要一根火柴摩擦燃烧为灰烬作为代价。而一个打火机可以持续供给。同样如果你只想在某个线程某个类想要得到执行改类的一个方法，如果这个类占用的内存、空间巨大，耗费的时间也很大的话，如果频繁创造是一笔很大的负担，那样就不如咱们就创建好一个然后供我们使用就好啦。
一定程度又像是他人和个人的区别。每个人都可能干过相同的事情，可能很多人都在校园的跑道上跑过步，但他们并不是你，你也可能在操场上跑过很多圈。但只有你知道你的思考。同样单例模式在一定程度可以看作一个人生，它可能有很多职能，也可能干过很多事、重复过很多事。但它可能对自己有从始至终的思考和记录。它可能有些全局参数记录着程序从始至终一些状态、信息等等。也就是它一直是它，你也一直是你独特的自己。
 
其他等等
 
至于单例模式的优缺点，这里就不作详细介绍了。无非是关于性能职能、时间、空间、拓展性等方面的一些讨论。这个可以参考不同人的不同理解。本文主要记录单例模式的实现方面。而同样单例模式实现上分为饿汉式和懒汉式：
 
 
单例模式创建要求：
 
某个类只能有一个实例(构造器私有化)
它必须自行创建这个实例(含有一个改类的静态变量来保存这个唯一的实例)
自行向整个系统提供这个实例(直接暴露或者用静态变量的get方法)
 
饿汉式
 
直接创建对象，不存在线程安全问题 。对于饿汉式的实现是相对简单和容易的。在实际遇到这种类似的思想其实也很多。
 理解：
 
这个饿汉式就好比双十一，你一下把你家里感觉可能缺的日后可能需要(也不一定需要的)全部给买了。比如啥洗衣液屯、棉衣棉鞋棉被日后可能要买也买。然后啥微波炉、烤箱我感觉可能以后会用我也买买买。买买买。这一下就买全了。但是：
 
同样在实际的生产，我们一个项目中可能有很多这样单例的存在，如果一次性启动的话对时间花销真的是太大。可能对程序的压力和体验都很差。所以一般很少直接使用。这种体验，像极了你打开某个网页等待JavaScript和css的过程。
 
饿汉式的几种实现方式：
 01 . 直接实例化饿汉式(简洁直观)
 
/**
 * 饿汉式
 * 直接创建实例，不管是否需要这个对象
 */
public class singleton1 {
    public  static  final singleton1 INSTANCE = new singleton1();
    private singleton1()
    {}
}
 
02 . 枚举式(最简洁)
 
public enum singleton2 {
   INSTANCE
}
 
03 . 静态代码块饿汉式(适合复杂实例化)
 
public class singleton3 {
    public static final singleton3 INSTANCE;
    static {
        /***
         * 有可能一些数据需要配置，需要从类加载器加载
         * 例如从某xxx.properties加载某些配置信息，我们只需更改配置文件不需要更改代码
         */
        INSTANCE=new singleton3();
    }
    private  singleton3()
    {}
}
 
懒汉式
 
我们知道饿汉式在早早把对象创建好，在执行一些其他逻辑时候不存在线程安全的问题。但是懒汉式就不一样啦，延迟创建对象可能会有线程安全问题。
 01 .线程不安全(适合单线程)
 
/***
 * 懒汉式：构造器私有化
 * 静态变量保存实例
 * 提供一个静态方法，获取这个实例对象
 */
public class singleton4 {
    private static singleton4 instance;
    private  singleton4(){}
    public  static singleton4 getInstance()
    {
        if (instance==null)
            instance = new singleton4();
        return  instance;
    }
}
 
对于这种单线程没问题，但是如果如果两个或多个线程来同时访问instance如果都为null同时申请的时候会遇到下图等之类问题，这违背了单例模式的设计原则并且可能会对系统数据造成错误。
 
 02 .线程安全(适用于多线程)
 怎么优化上述的懒汉式单例模式呢？既然不允许多个线程这样同时访问，那么咱们给它上个锁不久行了嘛！
 
public class singleton5 {
    private static singleton5 instance;
    private  singleton5(){}
    public  static singleton5 getInstance()
    {
        synchronized (singleton5.class)
        {
            if (instance == null)
                instance = new singleton5();
        }
        return  instance;
    }
}
 
但是这样有啥问题呢？就是我获取这个单例对象的时候，被上锁了。你气不气？我们就是在创建这个单例时候多线程可能出现点问题，咱么获取的时候不存在线程安全问题啊。。你为啥获取也要锁？？
 
这就好比，咱们都喜欢看美女，跟美女说话要排队一个一个来，只能一个在一个时刻，但是你看美女不需要排队啊！！！
 
 03 .线程安全推荐版(适用于多线程)
 对于上述存在的问题，咱们只需要双重判定就行了。
 
首先判断instance是不是为null。如果不是null说明被实例化过直接返回即可！nice！
如果instance为null？上锁之后再判空实例化。
 
public class singleton6 {
    private static singleton6 instance;
    private singleton6(){}
    public  static singleton6 getInstance()
    {
        if(instance==null) {
            synchronized (singleton6.class) {
                if (instance == null)
                    instance = new singleton6();
            }
        }
        return instance;
    }
}
 
两个判断为null？为啥要两个？
 
第一个：用来判断是否为空需要上锁new 实例。
第二个：上锁后虽然只有一个会执行当前方法，但是很可能都为null的时候两个或多个都为null上锁的想构造。然后后面线程在等待同时前面线程构造好了，那么它就不需要再去构造这个instance啦！直接不操作就行了。
 
就这样，稍微完美的方法就这样产生了。
 
04 .静态内部类形式(适用于多线程)
 上面的方法可能有些复杂，而静态内部类也是个好方式。主要是静态内部类和外部类不是一起加载的，并且你去调用它的时候他就会初始化，并且类加载是线程安全的，这个不需要考虑线程安全问题。当加载完之后你就可以直接拿啦。这样也能达到延迟加载的作用。
 
这个更详细你可以自己研究静态变量(类变量)、静态内部类等等加载顺序，研究下`static关键字。
 
public class singleton7 {
    private singleton7(){}
    private static class inner
    {
        private static final singleton7 instance=new singleton7();
    }
    public static singleton7 getInstance()
    {
        return inner.instance;
    }
}
 
结语
 
学习参考尚学堂单例讲解以及百科、菜鸟教程等等，有些区别但是大部分实现都是相似的，带上个人理解分享给大家。如果有问题和疏漏还请指教！
 
欢迎交流学习、欢迎关注微信公众号：bigsai
 

单例模式即一个JVM内存中只存在一个类的对象实例，并提供一个访问它的全局访问点。
 
 
分类
 
1、懒汉式
 类加载的时候就创建实例
 2、饿汉式
 使用的时候才创建实例
 3、当然还有其他的生成单例的方式，双重校验锁，枚举和静态内部类
 
懒汉式
 
线程不安全，不可用
 
public class Singleton { 
     private static Singleton instance; 
     private Singleton (){} 
  
     public static Singleton getInstance() { 
     if (instance == null) { 
         instance = new Singleton(); 
     } 
     return instance; 
     } 
}
 
线程安全，同步方法，效率低，不推荐
 
public class Singleton { 
     private static Singleton instance; 
     private Singleton (){} 
     public static synchronized Singleton getInstance() { 
     if (instance == null) { 
         instance = new Singleton(); 
     } 
     return instance; 
     } 
}
 
线程不安全，会产生多个实例，不可用
 
public class Singleton {
     private static Singleton singleton;
     private Singleton() {}

     public static Singleton getInstance() {
         if (singleton == null) {
             synchronized (Singleton.class) {
                 singleton = new Singleton();
             }
         }
         return singleton;
     }
}
 
饿汉式
 
无线程安全问题，不能延迟加载，影响系统性能
 4.
 
public class Singleton { 
    private static Singleton instance = new Singleton(); 
    private Singleton (){} 
    public static Singleton getInstance() { 
    	return instance; 
    } 
}
 
 
public class Singleton { 
     private static Singleton instance = null; 
     static { 
 		instance = new Singleton(); 
     } 
     private Singleton (){} 
     public static Singleton getInstance() { 
  		return instance; 
     } 
}
 
双重校验锁，线程安全，推荐使用
 
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 static class SingletonHolder { 
  		private static final Singleton INSTANCE = new Singleton(); 
    } 
    private Singleton (){} 
    public static final Singleton getInstance() { 
  		return SingletonHolder.INSTANCE; 
    } 
}
 
枚举类型，无线程安全问题，避免反序列华创建新的实例，很少使用
 
public enum Singleton { 
     INSTANCE; 
     public void whateverMethod() { 
     } 
}
 
 
 
注意事项
 
 
1、考虑多线程问题
 2、单例类构造方法要设置为private类型禁止外界new创建
 private Singleton() {}
 3、如果类可序列化，考虑反序列化生成多个实例问题，解决方案如下
 
private Object readResolve() throws ObjectStreamException { 
  	// instead of the object we're on, return the class variable INSTANCE 
	return INSTANCE; 
}
 
使用场景
 
1、工具类对象
 2、系统中只能存在一个实例的类
 3、创建频繁或又耗时耗资源且又经常用到的对象
 
下面是单例模式在JDK的应用
 
 另外，spring容器中的实例默认是单例饿汉式类型的，即容器启动时就实例化bean到容器中，当然也可以设置懒汉式defalut-lazy-init="true"为延迟实例化，用到时再实例化。
 
彩蛋
 
欢迎加入请求群学习交流：
 Java/Python架构师①群：415777345
 电脑PC用户快捷加入（点击超链接）：415777345
 手机QQ扫码加入：
 
 SpringBoot SpringCloud Docker K8s ①群：317945902
 电脑PC用户快捷加入（点击超链接）：317945902
 手机QQ扫码加入：
 
 欢迎进群交流探讨！