Effective Java - 构造器私有、枚举和单例

目录

• • 饿汉式单例
    • 静态常量
    • 静态代码块
  • 懒汉式单例
    • 尝试加锁
    • 同步代码块
    • 双重检查
  • 静态内部类单例
  • 枚举单例

Singleton 是指仅仅被实例化一次的类。Singleton表明了无状态的对象像是方法或者本质上是惟一的系统组件。使类称为Singleton 会使它的客户端测试变得十分困难。由于不可能给Singleton替换模拟实现。除非实现一个充当其类型的接口

饿汉式单例

静态常量

下面有两种方法实现一个单例，二者都基于保持构造器私有而且导出一个公有的静态成员提供一个惟访问该实例的入口。在第一种方法中，这个成员的属性是final的

// 提供属性是公有的、惟一的单例
public class Elvis {
  public static final Elvis INSTANCE = new Elvis();
  private Elvis();
  
  public void leaveTheBuilding();
}

这是一个饿汉式的实现。这个私有的构造器仅仅被调用一次，由于Elvis 是 static final的，因此INSTANCE是一个常量，编译期间进行初始化，而且值只能被初始化一次，导致INSTANCE不能再指向任意其余的对象，没有任何客户端可以改变这个结果。可是须要注意一点：有特权的客户端可以使用反射中的AccessibleObject.setAccessible访问私有的构造器。为了防护这种攻击，把构造器修改成在第二次实例化的时候抛出异常。见以下的例子

public class Elvis {

    static boolean flag = false;
    private Elvis(){
        if(flag == false) {
            flag = !flag;
        }
        else {
            throw new RuntimeException("单例模式被侵犯！");
        }
    }

    public static class SingletonHolder {
        private static final Elvis INSTANCE = new Elvis();
    }

    public static Elvis getInstance(){
        return SingletonHolder.INSTANCE;
    }

    public static void main(String[] args) throws Exception {
        Class<Elvis> el = Elvis.class;
        // 得到无参数私有的构造器
        Constructor<Elvis> constructor = el.getDeclaredConstructor();
        // 暴力破解private 私有化
        constructor.setAccessible(true);
        // 生成新的实例
        Elvis elvis = constructor.newInstance();
        Elvis instance = Elvis.getInstance();
        System.out.println(elvis == instance);

    }
}

Exception in thread "main" java.lang.ExceptionInInitializerError
    at effectiveJava.effective03.Elvis.getInstance(Elvis.java:22)
    at effectiveJava.effective03.Elvis.main(Elvis.java:33)
Caused by: java.lang.RuntimeException: 单例模式被侵犯！
    at effectiveJava.effective03.Elvis.<init>(Elvis.java:13)
    at effectiveJava.effective03.Elvis.<init>(Elvis.java:5)
    at effectiveJava.effective03.Elvis$SingletonHolder.<clinit>(Elvis.java:18)
    ... 2 more

注释掉利用反射获取私有构造函数的代码，发现instance实例能够正常输出

Elvis instance = Elvis.getInstance();
System.out.println(instance);

console: effectiveJava.effective03.Elvis@266474c2

在实现Singleton 的第二种方法中，公有的成员是个静态方法

public class ElvisSingleton {

    private static final ElvisSingleton INSTANCE = new ElvisSingleton();
    private ElvisSingleton(){}
    public static ElvisSingleton newInstance(){
        return INSTANCE;
    }
    public void leaveBuilding(){}
    
}

对于静态方法newInstance来讲全部的调用，都会返回一个INSTANCE对象，因此，永远不会建立其余ElvisSingleton实例

公有属性最大的优点在于可以很清楚的描述类是单例的：公有的属性是final的，因此老是可以包含相同的对象引用。第二个优点就是就是比较简单。

静态代码块

静态代码块是静态常量的变种，就是把静态常量的初始化放在了静态代码块中解析，初始化。读者可能对这种方式产生疑惑，请详见

类加载机制 https://blog.csdn.net/ns_code/article/details/17881581

public class ElvisStaticBlock {

    private static final ElvisStaticBlock block;
    static {
        block = new ElvisStaticBlock();
    }

    private ElvisStaticBlock(){}
    public static ElvisStaticBlock newInstance(){
        return block;
    }
}

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

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

懒汉式单例

与饿汉式对应的就是懒汉式，这二者都是属于单例模式的应用，懒汉式含有一层懒加载(lazy loading)的概念，也叫作惰性初始化。

public class ElvisLazyLoading {

    private static ElvisLazyLoading instance;
    private ElvisLazyLoading(){}

    public static ElvisLazyLoading newInstance(){
        if(instance == null){
            instance = new ElvisLazyLoading();
        }
        return instance;
    }
}

初始的时候不会对INSTANCE进行初始化，它的默认值是null，在调用newInstance方法时会判断，若INSTANCE为null，则会把INSTANCE的引用指向ElvisLazyLoading的构造方法。

这种方式可以实现一个懒加载的思想，可是这种写法会存在并发问题，因为多线程各自运行本身的执行路径，当同时执行到 INSTANCE = new ElvisLazyLoading() 代码时，各自的线程都认为本身应该建立一个新的ElvisLazyLoading对象，因此最后的结果可能会存在多个ElvisLazyLoading 实例，因此这种方式不推荐使用

尝试加锁

很显然的，能够尝试对newInstance()方法加锁来避免产生并发问题，可是这种方式不可能，由synchronized加锁会致使整个方法开销太大，在碰见相似问题时，应该尝试换一种方式来解决，而不该该只经过简单粗暴的加锁来解决一切并发问题。

public synchronized static ElvisLazyLoading newInstance(){
  if(INSTANCE == null){
    INSTANCE = new ElvisLazyLoading();
  }
  return INSTANCE;
}

同步代码块

synchronized关键字不只能够锁住方法的执行，也能够对方法中的某一块代码进行锁定，也叫作同步代码块

public class Singleton {

    private static Singleton instance;

    private Singleton() {}

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

不要以为只要加锁了，就不会存在线程安全问题，线程是Java中很重要的一个课题，须要细细研究。这种同步代码块的方式也会存在线程安全问题，当多个线程同时判断本身的singleton 实例为null的时候，一样会建立多个实例。

双重检查

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

public class ElvisDoubleCheck {

    private static volatile ElvisDoubleCheck instance;
    private ElvisDoubleCheck(){}

    public static ElvisDoubleCheck newInstance(){
        if(instance == null){
            synchronized (ElvisDoubleCheck.class){
                if (instance == null){
                    instance = new ElvisDoubleCheck();
                }
            }
        }
        return instance;
    }
}

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

静态内部类单例

静态内部类的单例与饿汉式采用的机制相似，但又有不一样。二者都是采用了类装载的机制来保证初始化实例时只有一个线程。不一样的地方在饿汉式方式是只要Elvis类被装载就会实例化，没有Lazy-Loading的做用，而静态内部类方式在ElvisStaticInnerClass类被装载时并不会当即实例化，而是在须要实例化时，调用newInstance方法，才会装载SingletonInstance类，从而完成ElvisStaticInnerClass的实例化。

public class ElvisStaticInnerClass {

    private ElvisStaticInnerClass(){}

    private static class SingletonInstance{
        private static final ElvisStaticInnerClass instance = new ElvisStaticInnerClass();
    }

    public static ElvisStaticInnerClass newInstance(){
        return SingletonInstance.instance;
    }
}

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

枚举单例

实现Singleton的第四种方法是声明一个包含单个元素的枚举类型

public enum  ElvisEnum {

    INSTANCE;

    public void leaveTheBuilding(){}
}

这种方法在功能上与公有域方法类似，但更加简洁。无偿地提供了序列化机制，有效防止屡次实例化，即便在面对复杂的序列化或者反射攻击的时候。单元素的枚举类型常常成为实现Singleton的最佳方法。

优势: 系统内存中该类只存在一个对象，节省了系统资源，对于一些须要频繁建立销毁的对象，使用单例模式能够提升系统性能。

缺点：当想实例化一个单例类的时候，必需要记住使用相应的获取对象的方法，而不是使用new，可能会给其余开发人员形成困扰，特别是看不到源码的时候。

后记：

看完本文，你是否对构造器私有、枚举和单例这个主题有了新的认知呢？

你至少应该了解：

1. 单例模式的几种写法及其优缺点分析
2. 为何反射可以对私有构造器产生破坏？
3. 有哪几种比较好用的线程安全的单例模式？

公众号提供 优质Java资料 以及CSDN免费下载 权限，欢迎你关注我

参考资料：

如何防止单例模式被JAVA反射攻击 https://blog.csdn.net/u013256816/article/details/50525335

单例模式的八种写法比较

《Effective Java》