Android一些面试题的整理和学习记录之单例模式(一)

1、定义

单例模式是一种常用的软件设计模式，定义为：单例对象的类只允许一个实例存在。

2、使用时的注意事项

在多线程的使用场景下使用单例需注意：如果当唯一实例还未被创建时，有两个线程同时调用单例的创建方法，这时候两个线程里都检测到没有唯一单例的时候，这时候会被两个线程同时两个单例实例被构造出来，违反了单例模式中的唯一实例的原则，所以在处理的时候，必须为指示类是否已经实例化的变量提供一个互斥锁(虽然这样会降低效率)。

3、单例的几种写法

a)饿汉式（静态常量实现）---一般写法

优点：这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题。

缺点：在类装载的时候就完成实例化，没有达到Lazy Loading的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费。

public class Singleton{

    private final static  Singleton  INSTANCE =new Singleton();  //静态常量

    private Singleton(){};  //私有构造
    
    //获取实例的静态方法
    public static Singleton getInstance(){

        return INSTANCE ;

       } 

}

b)饿汉式（静态代码块)----优缺点同第一种写法

public class Singleton{

      private static Singleton INSTANCE;
      
      //静态代码块
      static{
          INSTANCE = new Singleton(); 
        }
        
       private Singleton(){}; //私有构造

       public static Singleton getInstance(){
            
            return INSTANCE ;   

        }
}

c)懒汉式（线程不安全）[多线程不能用]

public class Singleton{
    
    private static Singleton instance ;

    private Singleton(){};

    public static Singleton getInstance(){
        if(null == instance ){
            instance = new Singleton();

        }
        
        return instance ;
       
    }
}

d) 懒汉式（线程安全，同步方法）【不推荐使用】

优点：解决了上面的线程不安全问题

缺点：效率低，每个线程访问getInstance()时都要进行同步，其实只要执行了一次之后，再调用就可以直接return了。

public class Singleton{

    private static Singleton instance ;

    private Singleton(){};

    public static synchronized Singleton getInstance()
    {

        if(null == instance)
          {
           instance = new Singleton();
           }
        return instance ;
    }
}

e)懒汉式（线程同步，同步代码块）【不推荐使用】

由于上一个实现方式同步效率太低，所以摒弃同步方法，改为同步产生实例化的的代码块。但是这种同步并不能起到线程同步的作用。跟第3种实现方式遇到的情形一致，假如一个线程进入了if (singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。

public class Singleton{

     private static  Singleton instance;

     private Singleton(){};

     public static Singleton  getInstance(){

            if(null == instance)
             {
                synchronized (Singleton.class)
                {
                    instance = new Singleton();
                }
                
             }

            return instance;
        }

}

f) 双重检查（推荐使用）

Double-Check概念对于多线程开发者来说不会陌生，如代码中所示，我们进行了两次if (singleton == null)检查，这样就可以保证线程安全了。这样，实例化代码只用执行一次，后面再次访问时，判断if (singleton == null)，直接return实例化对象。

优点：线程安全；延迟加载；效率较高。

public  class Singleton{

   private static  volatile Singleton instance ;

   private Singleton(){};

   public static Singleton getInstance(){

        if(null == instance ){

            synchronized(Singleton.class){

                if(null == instance){
                    instance = new Singleton();
                }

             }
        }
 
        return instance ;
    }
}

g)静态内部类（推荐使用）

这种方式跟饿汉式方式采用的机制类似，但又有不同。两者都是采用了类装载的机制来保证初始化实例时只有一个线程。不同的地方在饿汉式方式是只要Singleton类被装载就会实例化，没有Lazy-Loading的作用，而静态内部类方式在Singleton类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载SingletonInstance类，从而完成Singleton的实例化。

类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。

优点：避免了线程不安全，延迟加载，效率高。

public class Singleton{

    private Singleton(){};

    private static class SingletonInstance{

        private static final Singleton instance = new Singleton();
    
    }

    public static Singleton getInstance(){

        return SingletonInstance.instance ;
    }

}

h)枚举（推荐使用---最好的单例模式）

public enum Singleton{
    INSTANCE;

     public void whateverMethod() {

    }
}

问题点：为什么说枚举是最好的单例模式？

单例模式有懒汉饿汉，双重检查锁，静态内部类等等的实现方式，但在Effective Java一书中推荐使用枚举来实现单例模式，那为什么要使用枚举类来实现单例模式呢？

1.书写简单，仅仅5行代码就能实现单例模式。

2.枚举类能防止破坏单例模式。

2.1.枚举类能防止利用反射方式获取枚举对象

原因：调用反射newInstance方法时会检查是否为枚举类，如果是将报错，错误如下：

Exception in thread "main" java.lang.IllegalArgumentException: Cannot reflectively create enum objects
2.2.枚举类能防止使用序列化与反序列化获取新的枚举对象

原因：在序列化的时候Java仅仅是将枚举对象的name属性输出到结果中，反序列化的时候则是通过java.lang.Enum的valueOf方法来根据名字查找枚举对象。同时，编译器是不允许任何对这种序列化机制的定制的，因此禁用了writeObject、readObject、readObjectNoData、writeReplace和readResolve等方法。