第3条:用私有构造器或者枚举类型强化Singleton属性

Java基础

浏览数:190

2020-5-30

实现Singleton模式,需要要把构造器保持为私有的,并导出公有的静态成员,以便允许客户端能够访问该类的唯一实例。

  1. 饿汉式(Eager mode):单例对象是个 final域,在类加载期间,就实例化一个对象交给自己的引用instance,如:
// Singleton with Eager mode
public class SingletonA
{
    //实例化一个对象交给自己的引用
    private static final instance = new SingletonA();
    //私有化构造器
    private SingletonA(){}
    //返回单例对象
    public static SingletonA getInstance()
    {
        return instance;
    }
}
  1. 懒汉式(Lazy mode)公有的成员是个静态工厂方法,在调用取得实例方法的时候才会实例化对象
  • 懒汉第1式:
//Singleton with Lazy mode
public class SingletonB
{
    private static instance;
    private SingletonB(){}
    public static SingletonB getInstance()
    {
        if(instance == null)
            instance = new SingletonB();
        return instance;
    }
}

如果线程1进入了if语句,但还未实例化instance,此时,线程2访问到getInstance的if判断,因为instance还未实例化,所以也进入if内部;于是线程1和线程2,最后创建了两个实例

  • 懒汉第2式:同步锁
public static synchronized SingletonB getInstance()
{
    if(instance == null)
       instance = new SingletonB();
    return instance;
}

可以有效防止多线程在执行getInstance方法得到2个对象,但是:

只有在instance为null时,才必须要求同步。一旦singleton不为null,系统依旧花费同步锁开销

  • 懒汉第3式:
public static SingletonB getInstance()
{
    
    if(instance == null)//1
        synchronized(SingletonB.class)//2
        {
            instance = new SingletonB();//3
        }
        return instance;
}

这种写法减少了锁开销,但是依旧可能创建了2个对象。

  1. 线程1执行到1挂起,线程1认为singleton为null
  2. 线程2执行到1挂起,线程2认为singleton为null
  3. 线程1被唤醒执行synchronized块代码,走完创建了一个对象
  4. 线程2被唤醒执行synchronized块代码,走完创建了另一个对象
  • 懒汉第4式:双重锁定检查(DCL)
public static SingletonB getInstance()
{
    
    if(instance == null)//1
        synchronized(SingletonB.class)//2
        {
            if(instance == null)
            {
                instance = new SingletonB();//3
            }
        }
        return instance;
}

看是没有问题,但在instance = new SingletonB()这句中,却暗藏杀机,因为jvm在执行这句代码时,实际分为三步:开辟内存空间,赋值给引用,初始化数据。这是需要消耗时间。

  • 懒汉最终式:volatile

volatile修饰的成员变量在每次被线程访问时,都强迫从共享内存中重读该成员变量的值。

//Singleton with Lazy mode
public class SingletonB
{
    private static volatile instance;
    private SingletonB(){}
    public static SingletonB getInstance()
    {
        if(instance == null)//1
        synchronized(SingletonB.class)//2
        {
            if(instance == null)
            {
                instance = new SingletonB();//3
            }
        }
        return instance;
    }
}

volatile变量具有synchronized 的可见性特性,但是不具备原子特性。这就是说线程能够自动发现volatile变量的最新值

  1. Lazy initialization holder class模式

根据JLS(Java Language Specification)中的规定,一个类在一个ClassLoader中只会被初始化一次,这点是JVM本身保证的

public class SingletonC
{
    private static instance;
    //私有化构造器
    private SingletonC(){}
    //返回单例对象
    public static SingletonC getInstance()
    {
        return SingletonHolder.INSTANCE;
    }
    private static class SingletonHolder
    {
        //单例对象实例
        static final SingletonC INSTANCE = new SingletonC();     
    }  
}
  • 这种写法仍然使用JVM本身机制保证线程安全问题
  • 由于SingletonHolder是私有的,除了getInstance()之外没有办法访问它,因此它是懒汉式的
  • 同时读取实例的时候不会进行同步,没有性能缺陷
  • 也不依赖JDK版本
  1. 从其他途径屏蔽构造单例对象的方法
  • 直接new单例对象

一般加入一个private或者protected的构造函数

  • 通过反射构造单例对象

需要在ReflectPermission(“suppressAccessChecks”) 权限下使用安全管理器(SecurityManager)的checkPermission方法来限制这种突破。 一般来说,不会真的去做这些事情,都是通过应用服务器进行后台配置实现

  • 通过序列化构造单例对象

单例对象有必要实现Serializable接口,则应当同时实现readResolve()方法,以保证反序列化的时候得到原来的对象

public class Singleton implements Serializable 
{
    private static class SingletonHolder
    {
        static final Singleton INSTANCE = new Singleton();     
    }     
    public static Singleton getInstance()
    {     
        return SingletonHolder.INSTANCE; 
    }
    //private的构造函数用于避免外界直接使用new来实例化对象  
    private Singleton() {     
    }     
    //readResolve方法应对单例对象被序列化   
    private Object readResolve() {     
        return getInstance();     
    }     
}    
  1. 单例与枚举

按照《Effective Java 第二版》中的说法:单元素的枚举类型已经成为实现Singleton的最佳方法。用枚举来实现单例非常简单,只需要编写一个包含单个元素的枚举类型即可。

public enum SingletonEnum
{
    INSTANCE;
    private String field;
    public String getField()
    {
        return field;
    }
    public void setField(String field)
    {
        this.field = field;
    }
    @Override
    public String toString()
    {
        return "SingletonEnum{" +
            "field='" + field + '\'' +
            '}';
    }
}
  • 自由序列化
  • 保证只有一个实例(使用反射机制也无法多次实例化一个枚举量)
  • 线程安全

Singleton Mode总结

  1. 优点
  • 在内存中只有一个对象,节省内存空间
  • 避免频繁的创建销毁对象,可以提高性能
  • 避免对共享资源的多重占用
  • 可以全局访问
  1. 适用场景
  • 需要频繁实例化然后销毁的对象
  • 创建对象时耗时过多或者耗资源过多,但又经常用到的对象。
  • 有状态的工具类对象。
  • 频繁访问数据库或文件的对象。

作者:Ocean_Sky