（4）单例模式

一：单例模式的优点

　         --->单例类只能有一个实例

             --->单例类必须自己创建自己的唯一实例。

             --->单例类必须给所有其他对象提供这一实例。

二：单例模式分类

　　--->饿汉模式

        --->懒汉模式


三：单例模式应用场景

        --->

四：单例模式的角色

        --->
五：单例模式的代码示例

饿汉模式：

package com.yeepay.sxf.interfaces.impl;
/**
 * 饿汉单例模式
 * 是典型的空间换时间，当类装载的时候就会创建类的实例，不管你用不用，先创建出来，然后每次调用的时候，就不需要再判断，节省了运行时间。
 * @author sxf
 *
 */
public class SingObj {
    /**
     * 持有自己的引用
     */
    private static SingObj singObj=new SingObj();
    /**
     *似有化构造器
     */
    private SingObj(){
        
    }
    /**
     * 提供静态方法返回自身对象
     * @return
     */
    public static SingObj getSingObj(){
        return singObj;
    }
}

懒汉模式：

（1）线程安全的懒汉模式（并发速度缓慢）

package com.yeepay.sxf.interfaces.impl;
/**
 * 懒汉模式
 * 
 * (1)懒汉式是典型的时间换空间,就是每次获取实例都会进行判断，看是否需要创建实例，浪费判断的时间。当然，如果一直没有人使用的话，那就不会创建实例，则节约内存空间
 * (2)由于懒汉式的实现是线程安全的，这样会降低整个访问的速度，而且每次都要判断。那么有没有更好的方式实现呢？
 *
 */
public class SingObj2 {
    /**
     * 持有自身引用
     */
    private static SingObj2 singObj2=null;
    
    /**
     * 构造器私有化
     */
    private void  SingObj2(){
        
    }
    
    /**
     * 提供静态方法返回对象.同步方法，防止出现多个对象，违反单例规则
     * @return
     */
    public static synchronized SingObj2 getSingObj2(){
        if(singObj2==null){
            singObj2=new SingObj2();
        }
        return singObj2;
    }
}

（2）线程安全的懒汉模式（并发速度提高）

package com.yeepay.sxf.interfaces.impl;
/**
 * 懒汉模式升级版
 * 
 * @author sxf
 *
 */
public class SingObj3 {
    /**
     * 持有自身对象的引用
     */
    private static SingObj3 singObj3=null;
    
    /**
     * 构造器似有化
     */
    private void SingObj3(){
        
    }
    /**
     * 升级版的静态方法返回单例对象引用。只需要第一次创建时才用到同步。以后获取就不需要同步
     * @return
     */
    public static SingObj3 getSingObje3(){
        if(singObj3==null){
            synchronized (SingObj3.class) {
                if(singObj3==null){
                    singObj3=new SingObj3();
                }
            }
        }
        
        return singObj3;
    }

}

（3）内部类的懒汉模式

package com.yeepay.sxf.interfaces.impl;
/**
 * 懒汉模式的再次升级版
 * 使用类级内部类
 * 什么是类级内部类？
 *       （1）简单点说，类级内部类指的是，有static修饰的成员式内部类。如果没有static修饰的成员式内部类被称为对象级内部类。
　　（2）类级内部类相当于其外部类的static成分，它的对象与外部类对象间不存在依赖关系，因此可直接创建。而对象级内部类的实例，是绑定在外部对象实例中的。
　　（3）类级内部类中，可以定义静态的方法。在静态方法中只能够引用外部类中的静态成员方法或者成员变量。
      （4）类级内部类相当于其外部类的成员，只有在第一次被使用的时候才被会装载
 * 
 * 多线程缺省同步所的机制
 * 大家都知道，在多线程开发中，为了解决并发问题，主要是通过使用synchronized来加互斥锁进行同步控制。但是在某些情况中，JVM已经隐含地为您执行了同步，这些情况下就不用自己再来进行同步控制了。这些情况包括：

　　1.由静态初始化器（在静态字段上或static{}块中的初始化器）初始化数据时

　　2.访问final字段时

　　3.在创建线程之前创建对象时

　　4.线程可以看见它将要处理的对象时
 * @author sxf
 *
 */
public class SingObj4 {
    /**
     * 构造器似有化
     */
    private SingObj4(){}
    /**
     *    类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例
     *    没有绑定关系，而且只有被调用到时才会装载，从而实现了延迟加载。
     *    一旦加载，不会再次加载
     */
    private static class SingletonHolder{
        /**
         * 静态初始化器，由JVM来保证线程安全
         */
        private static SingObj4 instance = new SingObj4();
    }
    /**
     * 
     * @return
     */
    public static SingObj4 getInstance(){
        return SingletonHolder.instance;
    }
}

（4）枚举的懒汉模式

public enum Singleton {
    /**
     * 定义一个枚举的元素，它就代表了Singleton的一个实例。
     */
    
    uniqueInstance;
    
    /**
     * 单例可以有自己的操作
     */
    public void singletonOperation(){
        //功能处理
    }
}

单例，大家肯定都不陌生，这是Java中很重要的一个设计模式。稍微了解一点单例的朋友也都知道实现单例是要考虑并发问题的，一般情况下，我们都会使用synchronized来保证线程安全。

那么，如果有这样一道面试题：不使用synchronized和lock，如何实现一个线程安全的单例？你该如何回答？

C类应聘者：可以使用饿汉模式实现单例。如：

public class Singleton { 
     private static Singleton instance = new Singleton();
     private Singleton (){}
     public static Singleton getInstance() {
       return instance;
     }
}

还有部分程序员可以想到饿汉的变种：

public class Singleton {
     private Singleton instance = null;
     static {
         instance = new Singleton();
     }
     private Singleton (){}
     public static Singleton getInstance() {
         return this.instance;
     }
}

使用static来定义静态成员变量或静态代码，借助Class的类加载机制实现线程安全单例。

面试官：除了这种以外，还有其他方式吗？

B类应聘者：

除了以上两种方式，还有一种办法，就是通过静态内部类来实现，代码如下：

public class Singleton {
     private static class SingletonHolder {
         private static final Singleton INSTANCE = new Singleton();
     }
     private Singleton (){}
     public static final Singleton getInstance() {
         return SingletonHolder.INSTANCE;
     }
}

这种方式相比前面两种有所优化，就是使用了lazy-loading。Singleton类被装载了，但是instance并没有立即初始化。因为SingletonHolder类没有被主动使用，只有显示通过调用getInstance方法时，才会显示装载SingletonHolder类，从而实例化instance。

面试官：除了这种以外，还有其他方式吗？

A类应聘者：

除了以上方式，还可以使用枚举的方式，如：

public enum Singleton {
     INSTANCE;
     public void whateverMethod() {
     }
}

这种方式是Effective Java作者Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象，可谓是很坚强的壁垒。

面试官：以上几种答案，其实现原理都是利用借助了类加载的时候初始化单例。即借助了ClassLoader的线程安全机制。

所谓ClassLoader的线程安全机制，就是ClassLoader的loadClass方法在加载类的时候使用了synchronized关键字。也正是因为这样， 除非被重写，这个方法默认在整个装载过程中都是同步的，也就是保证了线程安全。

所以，以上各种方法，虽然并没有显示的使用synchronized，但是还是其底层实现原理还是用到了synchronized。

面试官：除了这种以外，还有其他方式吗？

A类应聘者：

还可以使用Java并发包中的Lock实现

面试官：本质上还是在使用锁，不使用锁的话，有办法实现线程安全的单例吗？

A+类面试者：

有的，那就是使用CAS。

CAS是项乐观锁技术，当多个线程尝试使用CAS同时更新同一个变量时，只有其中一个线程能更新变量的值，而其它线程都失败，失败的线程并不会被挂起，而是被告知这次竞争中失败，并可以再次尝试。实现单例的方式如下：

public class Singleton {
     private static final AtomicReference<Singleton> INSTANCE = new AtomicReference<Singleton>();

     private Singleton() {}

     public static Singleton getInstance() {
         for (;;) {
             Singleton singleton = INSTANCE.get();
             if (null != singleton) {
                 return singleton;
             }

             singleton = new Singleton();
             if (INSTANCE.compareAndSet(null, singleton)) {
                 return singleton;
             }
         }
     }
}

面试官：这种方式实现的单例有啥优缺点吗？

A++类面试者：

用CAS的好处在于不需要使用传统的锁机制来保证线程安全,CAS是一种基于忙等待的算法,依赖底层硬件的实现,相对于锁它没有线程切换和阻塞的额外消耗,可以支持较大的并行度。

CAS的一个重要缺点在于如果忙等待一直执行不成功(一直在死循环中),会对CPU造成较大的执行开销。

另外，如果N个线程同时执行到singleton = new Singleton();的时候，会有大量对象创建，很可能导致内存溢出。

面试官：你被录取了！