单例传说

在设计模式这个门派里面，有个很常见的招式，叫做单例派。

什么是单例

所谓单例，顾名思义，就是单个实例，使用单例模式可以让某个类全局只有一个实例。

单例的好处

对类的唯一实例做出访问控制
允许改变实例的数目
相比多例，单例更省资源

单例的缺点

不适用于变化的对象

由于单利模式中没有抽象层

滥用单例将带来一些负面问题

哪些场景适合使用单例

下面摘抄自龙哥的博客园

"在我的工作过程中，我发现所有可以使用单例模式的类都有一个共性，那就是这个类没有自己的状态，换句话说，这些类无论你实例化多少个，其实都是一样的，而且更重要的一点是，这个类如果有两个或者两个以上的实例的话，我的程序竟然会产生程序错误或者与现实相违背的逻辑错误。"
"这样的话，如果我们不将这个类控制成单例的结构，应用中就会存在很多一模一样的类实例，这会非常浪费系统的内存资源，而且容易导致错误甚至一定会产生错误，所以我们单例模式所期待的目标或者说使用它的目的，是为了尽可能的节约内存空间，减少无谓的GC消耗，并且使应用可以正常运作。"
"我稍微总结一下，一般一个类能否做成单例，最容易区别的地方就在于，这些类，在应用中如果有两个或者两个以上的实例会引起错误，又或者我换句话说，就是这些类，在整个应用中，同一时刻，有且只能有一种状态。"
" 一般实践当中，有很多应用级别的资源会被做成单例，比如配置文件信息，逻辑上来讲，整个应用有且只能在同在时间有一个，当然如果你有多个，这可能并不会引起程序级别错误，这里指的错误特指异常或者ERROR。但是当我们试图改变配置文件的时候，问题就出来了。"

单例的几种实现方式

1.第一种，标准的单例模式(懒汉式，没有并发情况)

public class Singleton {

    //静态的实例
   private static Singleton singleton = null;
   //私有化构造函数
   private Singleton(){}
   
   public static Singleton getSingleton(){
   
        if(singleton == null ){
            singleton = new Singleton();
        }
        
        return singleton;
   
   }

}

这种单例模式，算是最基本的一种，简单记忆为:
一个私有的静态空实例，
一个私有空构造，
一个公共的获取实例的方法

我们想一下，这种单例模式可能存在什么问题？
对，并发情况下，这个单例模式是不安全的，会造成多例；那么怎么解决呢？
第一种在获取实例的方法上加上同步关键字，变成下面这种

public class Singleton {

    //静态的实例
   private static Singleton singleton = null;
   //私有化构造函数
   private Singleton(){}
   
   public synchronized static Singleton getSingleton(){
   
        if(singleton == null ){
            singleton = new Singleton();
        }
        
        return singleton;
   
   }

}

这种方式在多线程的情况下，是安全的，但是，会造成很多无谓的等待。
(将整个方法都同步了，造成占用锁的时间会变长)我们同步的地方，只需要发生在单例的实例还没有创建的时候，也就是我们只需要保证在创造实例的时候是同步的就可以了。写法如下

public class Singleton {

    //静态的实例
   private static Singleton singleton = null;
   //私有化构造函数
   private Singleton(){}
   
   public static Singleton getSingleton(){
   
        if(singleton == null ){
            synchronized(Singleton.class){
                
                if(singleton == null ){
                    singleton = new Singleton();
                }
            }
        }
        
        return singleton;
   
   }
}

这里需要注意，在同步代码块里面也需要判断一下实例是否是空的。否则，当第一个线程进入，实例化完，还没返回，第二线程再次进入同步块里面的时候会继续实例化，造成多例。
这种基本没啥大的问题，但是，也并不是百分百完美
请看下面单例的单例写法

public class Singleton{

    private Singleton(){}

    private static class SingletonInstance{

        /**
        **类的静态属性只会在第一次加载类时初始化，这是JVM帮我们保证的，所以我们无需担心  并发访问的问题。所以在初始化进行一半的时候，别的线程是无法使用的，因为JVM会帮我们强行同步这个过程。另外由于静态变量只初始化一次，所以singleton仍然是单例的。
       ** /
        static Singleton instance = new Singleton();

    }

    public static Singleton getInstance(){

        return SingletonInstance.instance;

    }
}