首页手记设计模式笔记之-单例

设计模式笔记之-单例

标签：

Java 面试设计模式

带着问题思考：

单例模式存在的意义?
单例模式的几种写法?
单例模式在实战中的使用如何？
如何应对面试官？

为什么要用单例模式

单例模式要写都很简单，都知道最终就是返回一个单实例的对象.
那么为什么要那么折腾？因为这样可以确保 java 内存中只有一个这个类的实例，减少了内存开支。
可能大家觉得这才多少内存? 试想一下，1000 个对象，在同一个程序里面有大量的线程同时使用且 GC 没有及时回收，这会造成多大的资源占用。

Java对象的大小

基本数据的类型的大小是固定的，这里就不多说了。对于非基本类型的Java对象，其大小就值得商榷。
在Java中，一个空Object对象的大小是8byte，这个大小只是保存堆中一个没有任何属性的对象的大小。

看下面语句：
Object ob = new Object();
这样在程序中完成了一个Java对象的生命，但是它所占的空间为：4byte+8byte。4byte是Java栈中保存引用的所需要的空间。

而那8byte则是Java堆中对象的信息。因为所有的Java非基本类型的对象都
需要默认继承Object对象，因此不论什么样的Java对象，其大小都必须是大于8byte。

有了Object对象的大小，我们就可以计算其他对象的大小了。
Class NewObject {
int count;
boolean flag;
}
其大小为：空对象大小(8byte)+int大小(4byte)+Boolean大小(1byte)+空Object引用的大小(4byte)=17byte。按照最小8byte的计算=24 byte。
这还只是基本类型的对象，封装类型的最少16byte，也就是基本翻倍。在实际项目中，我们一个对象的大小一般都是超过 1024 byte。

单例模式的几种写法

饿汉模式
懒汉模式
枚举模式
内部类模式

饿汉模式

特点：

私有的构造器
私有静态的对象本身属性，且初始化 new 对象本身
公有的获取对象的方法

优点：从它的实现中我们可以看到，这种方式的实现比较简单，在类加载的时候就完成了实例化，避免了线程的同步问题。
缺点：由于在类加载的时候就实例化了，所以没有达到Lazy Loading(懒加载)的效果，也就是说可能我没有用到这个实例，但是它
也会加载，会造成内存的浪费(但是这个浪费可以忽略，所以这种方式也是推荐使用的)。

public class SingletonEHan {

    private SingletonEHan() {}

    /**
     * 单例模式的饿汉式[可用]
     */
    private static SingletonEHan singletonEHan = new SingletonEHan();

    public static SingletonEHan getInstance() {
        return singletonEHan;
    }
}

懒汉模式（线程不安全模式），不推荐使用

缺点：线程不同步，可能会产生多个实例，因此不推荐使用，这里贴上代码主要用来比较写法。

public class SingletonLanHan {
        
    private SingletonLanHan() { }
    /**
     * 单例模式的懒汉式[线程不安全，不可用]
     */
    private static SingletonLanHan singletonLanHan;

    public static SingletonLanHan getInstance() {
        if (singletonLanHan == null) { // 这里线程是不安全的,可能得到两个不同的实例
            singletonLanHan = new SingletonLanHan();
        }
        return singletonLanHan;
    }
}

懒汉模式（线程安全，但是效率不高）

优点：延迟加载，需要使用的时候才实例化，不会浪费性能，但其实浪费也是微乎其微。线程安全，保证只有一个实例。
缺点：每次使用 getSingletonLanHanTwo 方法的时候都会加锁。

其实这个方法里面只要求第一次实例化对象的时候加锁，然后返回对象，没有必要在每次请求的时候都加锁。这样我们还可以继续优化代码，做到双重验证+实例化时加锁。

public class SingletonLanHan {
        
    private SingletonLanHan() { }


    /**
     * 4. 懒汉式线程安全的:[线程安全，效率低不推荐使用]
     * <p>
     * 缺点：效率太低了，每个线程在想获得类的实例时候，执行getInstance()方法都要进行同步。
     * 而其实这个方法只执行一次实例化代码就够了，
     * 后面的想获得该类实例，直接return就行了。方法进行同步效率太低要改进。
     */
    private static SingletonLanHan singletonLanHanTwo;

    public static synchronized SingletonLanHan getSingletonLanHanTwo() {
        if (singletonLanHanTwo == null) { // 这里线程是不安全的,可能得到两个不同的实例
            singletonLanHanTwo = new SingletonLanHan();
        }
        return singletonLanHanTwo;
    }

}

懒汉模式（双重验证+锁）

特点：

私有的构造器
私有静态的对象本身属性
公有的获取对象的方法

优点：延迟加载，需要使用的时候才实例化，不会浪费性能，但其实浪费也是微乎其微。线程安全，双重验证机制，可以保证线程同步且只会实例一个对象；

public class SingletonLanHan {
  
  private SingletonLanHan() {  
  }

  /**
   * 单例模式懒汉式双重校验锁[推荐用]
   * 懒汉式变种,属于懒汉式的最好写法,保证了:延迟加载和线程安全
   */
  private static SingletonLanHan singletonLanHanFour;

  public static SingletonLanHan getSingletonLanHanFour() {
      if (singletonLanHanFour == null) {
          synchronized (SingletonLanHan.class) {
              if (singletonLanHanFour == null) {
                  singletonLanHanFour = new SingletonLanHan();
              }
          }
      }
      return singletonLanHanFour;
  }
}

枚举模式

懒汉模式、饿汉模式真的万无一失吗？不见得。

私有化构造器并不保险

“享有特权的客户端可以借助AccessibleObject.setAccessible方法，通过反射机制调用私有构造器。如果需要低于这种攻击，可以修改构造器，让它在被要求创建第二个实例的时候抛出异常。
序列化问题

任何一个readObject方法，不管是显式的还是默认的，它都会返回一个新建的实例，这个新建的实例不同于该类初始化时创建的实例。”当然，这个问题也是可以解决的，想详细了解的同学可以翻看《effective java》第77条：对于实例控制，枚举类型优于readResolve

枚举模式：

优点：避免同步问题；防止反序列化重新创建对象。

  /**
   * Created by holy
   * 枚举 [极推荐使用]
   *
   * 这里SingletonEnum.INSTANCE
   * 这里的INSTANCE 即为 SingletonEnum 类型的引用所以得到它就可以调用枚举中的方法了。
   * 借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象
   */
  
  public enum SingletonEnum {
  
      INSTANCE;
  
      private SingletonEnum() {
      }
  
      public void whateverMethod() {
  
      }
  
  }

上面的代码在编译后，会编译成

public final class SingletonEnum extends java.lang.Enum<SingletonEnum> {
    
    public static final SingletonEnum instance;

    public static SingletonEnum[] values();


    public static SingletonEnum valueOf(java.lang.String);


    public void whateverMethod();


    static {}
}

Java规范中规定，每个枚举类型及其定义的枚举变量在JVM中都是唯一的.

因此在枚举类型的序列化和反序列化上，
Java做了特殊的规定。在序列化的时候Java仅仅是将枚举对象的name属性输到结果中，反序列化的时候则是通过
java.lang.Enum的valueOf()方法来根据名字查找枚举对象。也就是说，序列化的时候只将属性名称输出，
反序列化的时候再通过这个名称，查找对应的枚举类型，因此反序列化后的实例也会和之前被序列化的对象实例相同。

内部类模式（推荐）

这种方式跟饿汉式方式采用的机制类似，但又有不同。
两者都是采用了类装载的机制来保证初始化实例时只有一个线程。
不同的地方:
在饿汉式方式是只要Singleton类被装载就会实例化,
内部类是在需要实例化时，调用getInstance方法，才会装载SingletonHolder类

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


   public class SingletonIn {
   
       private SingletonIn() {
       }
   
       private static class SingletonInHodler {
           private static SingletonIn singletonIn = new SingletonIn();
       }
   
       public static SingletonIn getSingletonIn() {
           return SingletonInHodler.singletonIn;
       }
   }

spring 中获取单例源码，采用的哪种方式？在面试中如何应对？


    @Nullable
    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null && this.isSingletonCurrentlyInCreation(beanName)) {
            Map var4 = this.singletonObjects;
            synchronized(this.singletonObjects) {
                singletonObject = this.earlySingletonObjects.get(beanName);
                if (singletonObject == null && allowEarlyReference) {
                    ObjectFactory<?> singletonFactory = (ObjectFactory)this.singletonFactories.get(beanName);
                    if (singletonFactory != null) {
                        singletonObject = singletonFactory.getObject();
                        this.earlySingletonObjects.put(beanName, singletonObject);
                        this.singletonFactories.remove(beanName);
                    }
                }
            }
        }
        return singletonObject;
    }

从源码分析来看，采用的就是双重验证+锁机制。现在为止，我们接触了单例的几种写法，也明白了其中的优点和缺点，在spring 中的源码我们也看了，
在面对面试官的提问的时候，就可以尽情聊（chui）天（niu）了。
我也面试过很多人，其实作为一个面试官，在单例这个问题上，只要回答到他们一些优缺点就感觉很不错了，因为说明真正理解了这种模式且对 JVM
有一定的理解，如果能够详细的做出详细比较并说出自己的理解，就算非常优秀了。

程序领域（id：think-holy）
作者：holy

点击查看更多内容