继续浏览精彩内容
慕课网APP
程序员的梦工厂
打开
继续
感谢您的支持,我会继续努力的
赞赏金额会直接到老师账户
将二维码发送给自己后长按识别
微信支付
支付宝支付

设计模式笔记之-单例

holyplace
关注TA
已关注
手记 18
粉丝 22
获赞 113

带着问题思考:

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

为什么要用单例模式

单例模式要写都很简单,都知道最终就是返回一个单实例的对象.
那么为什么要那么折腾?因为这样可以确保 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。

单例模式的几种写法

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

饿汉模式

特点:

  1. 私有的构造器
  2. 私有静态的对象本身属性,且初始化 new 对象本身
  3. 公有的获取对象的方法
  • 优点:从它的实现中我们可以看到,这种方式的实现比较简单,在类加载的时候就完成了实例化,避免了线程的同步问题。
  • 缺点:由于在类加载的时候就实例化了,所以没有达到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;
    }

}

懒汉模式(双重验证+锁)

特点:

  1. 私有的构造器
  2. 私有静态的对象本身属性
  3. 公有的获取对象的方法
  • 优点:延迟加载,需要使用的时候才实例化,不会浪费性能,但其实浪费也是微乎其微。线程安全,双重验证机制,可以保证线程同步且只会实例一个对象;

    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

打开App,阅读手记
1人推荐
发表评论
随时随地看视频慕课网APP