单例模式

　　单例模式（Singleton），是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，应用该模式的类一个类只有一个实例。即一个类只有一个对象实例。

　　优点： 
  　　  1.在单例模式中，活动的单例只有一个实例，对单例类的所有实例化得到的都是相同的一个实例。这样就 防止其它对象对自己的实例化，确保所有的对象都访问一个实例。
   　　 2.单例模式具有一定的伸缩性，类自己来控制实例化进程，类就在改变实例化进程上有相应的伸缩性。 
    　　3.提供了对唯一实例的受控访问。 
   　　 4.由于在系统内存中只存在一个对象，因此可以 节约系统资源，当 需要频繁创建和销毁的对象时单例模式无疑可以提高系统的性能。 省去了new操作符，降低了系统内存的使用频率，减轻GC压力。
   　　 5.避免对共享资源的多重占用。 

　　    6.有些类如交易所的核心交易引擎，控制着交易流程，如果该类可以创建多个的话，系统完全乱了。（比如一个军队出现了多个司令员同时指挥，肯定会乱成一团），所以只有使用单例模式，才能保证核心交易服务器独立控制整个流程。

　　缺点：

　　　1.不适用于变化的对象，如果同一类型的对象总是要在不同的用例场景发生变化，单例就会引起数据的错误，不能保存彼此的状态。 
　　    2.由于单利模式中没有抽象层，因此单例类的扩展有很大的困难。 
 　　   3.单例类的职责过重，在一定程度上违背了“单一职责原则”。 
　　    4.滥用单例将带来一些负面问题，如为了节省资源将数据库连接池对象设计为的单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出；如果实例化的对象长时间不被利用，系统会认为是垃圾而被回收，这将导致对象状态的丢失。 

　　下面写一个最基础的单例模式：

public class Singleton1 {

    //初始化一个实例对象
    private static Singleton1 sin = new Singleton1();
    
    /**
     * 私有构造器，防止被new出来
     */
    private Singleton1 (){
    }
    
    /**
     * 获取唯一实例的方法
     * @return
     */
    public static Singleton1 getInstance(){
        return sin;
    }
}

　　上面的代码中有一个缺点就是，这个类在加载的时候会直接new一个静态对象出来，当系统中这样的类比较多时，会使得项目启动非常慢。现在流行的设计都讲求“延迟加载”，我们可以在第一次使用的时候才初始化第一个该类对象，所以上面代码只适合在小程序。

　　对上面代码进行优化：

public class Singleton2 {
    //将此处改为null是为了懒加载
    private static Singleton2 sin = null;
        
    /**
     * 私有构造器，防止被new出来
     */
    private Singleton2 (){
    }
    
    /**
     * 第一次使用时初始化
     * @return
     */
    public static Singleton2 getInstance(){
        if (sin == null){
            sin = new Singleton2();
        }
        return sin;
    }
}

　　上面的单例模式基本可以满足程序，但是如果处于多线程环境下肯定会出现问题，所以在上面代码的基础上进行加锁。

public class Singleton3 {
    private static Singleton3 sin = null;

    private Singleton3 (){
    }
    
    /**
     * 在初始化方法上面进行加锁操作
     * @return
     */
    public static synchronized Singleton3 getInstance(){
        if (sin == null){
            sin = new Singleton3();
        }
        return sin;
    }
}

　　上面代码对初始化方法进行加锁，但是是对整个方法进行了加锁，粒度有点大，在性能上会有所下降，因为每次调用getInstance()，都要对对象上锁，事实上，只有在第一次创建对象的时候需要加锁，之后就不需要了，所以，这个地方需要改进。

public class Singleton4 {
    private static Singleton4 sin = null;

    private Singleton4 (){
    }
    
    /**
     * 只在new时进行加锁，双重同步锁
     * @return
     */
    public static Singleton4 getInstance(){
        if (sin == null){
            synchronized (sin){
                if (sin == null){
                    sin = new Singleton4();
                }
            }
        }
        return sin;
    }
}

　　上述代码看似没问题，其实还是会存在一些问题，当A线程执行sin = new Singleton4（）时，jvm会先划分一部分空白内存并赋值给sin，然后走出synchronized方法块，然后B线程执行时发现sin已经有引用就直接返回，其实此时sin还没有被实例化。所以就有了下面的方式，既不用加锁，也可以实现懒加载。

public class Singleton5 {
    private Singleton5 (){
    }
    /**
     * 使用内部类来维护单例。
     * @author Wuyouxin
     *
     */
    private static class SingletonFactory{
        private static Singleton5 sin = new Singleton5();
    }
    
    /**
     * 当第一次调用时加载上面的内部类，初始化sin
     * @return
     */
    public static Singleton5 getInstance(){
        return SingletonFactory.sin;
    } 
    
}

　　上述几种方式都可以实现单例模式，可以在不同的业务场景使用不同的方式去创建单例模式。