从Can not initialize class 报错谈谈静态与单例模式的区别与选择

文章目录

Could not initialize class

今天收到一个问题反馈，日志中的错误是 Caused by: java.lang.NoClassDefFoundError: **Could not initialize class** ClassA
很明显就是类ClassA初始化时报错了，所以去看ClassA的代码，如下:

`ClassA`的静态代码块实现

public final class ClassA() {
    
    
    // 静态对象service
    private static Service service;
    
    // 静态代码块
    static {
    
    
        // 从缓存中取出变量DATA_A DATA_B
        int dataA = Cache.instance().getInt("DATA_A");
        int dataB = Cache.instance().getInt("DATA_B");
        // 初始化静态对象service
        service = new Service(dataA, dataB);
    }
}

可以看出，ClassA有一个静态对象service，并且在类加载时会初始化该对象service (static代码块在类加载时执行)。
而service 的初始化参数时dataA，dataB 。都来自于缓存Cache。
查看报错堆栈信息，是Cache.instance().getInt("DATA_A")时报错了，原因在于此时缓存还未初始化。
继续查看Cache类的实现如下：

Cache类实现

public final class Cache {
    
    
    private static Cache instance = null;
    
    // 单例 懒汉模式
    public static Cache instance() {
    
    
        if (null == instance) {
    
    
            synchronized (Cache.class) {
    
    
                if (null == instance) {
    
    
                    // new instance
                    instance = new Cache();
                    // 从数据库加载缓存数据
                    instance.loadFromDB();
                }
            }
        }
        return instance;
    }
}

可以看出，Cache类实现是单例-懒汉模式。并且是双重判断的。一般来说没有线程安全问题？。
但是由于它的实现（9-12行）是先实例了一个Cache对象，然后再进行loadFromDB()从数据库加载数据，这就会导致多线程下会有线程获取到一个未加载缓存的缓存对象。

ex：
线程A 执行到10行，初始化了instance，
此时如果线程B也进入该方法的第6行，判断instance不为null，直接返回。
这时候的instance的对象换句话说就是个空缓存，还未加载数据，那么线程B去Cache.getInstance.getInt(code)时肯定会有问题的。

优化的的思路

如何修改呢？
要知道，我们应用中Cache的初始化在应用启动后会默认进行。
那么如果我们等它默认初始化好后再进行缓存的使用，不就不会出现问题了嘛。
简而言之，上述问题的根本原因是在于 对Cache的使用早于对Cache的默认初始化。
那么我们修改的思路就应该是： 将对Cache的使用——这里指对静态变量service的初始化，应该晚于Cache的初始化。
另外，我们最开始使用static的原因在于ClassA是个工具类，换句话说，就是避免 ”每调用一次ClassA的方法，就实例化一个classA“。

改造后的实现

综上所述，我们很自然地就想到了单例-懒汉模式。这样既能单例，又能将service的初始化延迟到使用它时（此时缓存已默认加载，就不会再有取不到缓存报错的问题）
改造后实现如下：

public final class ClassA {
    
    
    // 修改为非静态对象
    private Service service;
    
    // 单例
    private static ClassA classA = null;
    
    // 懒汉方式获取单例
    public static ClassA getInstance() {
    
    
        if (null == classA) {
    
    
            synchronized (ClassA.class) {
    
    
                if (null == classA) {
    
    
                    classA = new ClassA();
                }
            }
        }
        return classA;
    }
    
    // 重写构造方法
    private ThreadPoolUtils() {
    
    
         // 从缓存中取出变量DATA_A DATA_B
        int dataA = Cache.instance().getInt("DATA_A");
        int dataB = Cache.instance().getInt("DATA_B");
        // 初始化对象service
        service = new Service(dataA, dataB);
    }
    
}

浅谈单例与静态的区别与选择

1.区别

由上述例子可以看出，静态与单例最直接的区别就是 执行的时机：
静态代码块的ClassA，它对service的实例化在 类加载时
懒汉单例模式的ClassA，它对service的实例化在 ClassA 第一次初始化时
更详细的区别：

首先明确一下，静态成员并不是什么程序加载时创建并初始化的，而是类加载时进行。类的加载是第一次真正用到它的时候（拿类new实例或调用它的静态方法）进行的，而这个加载过程需要将 class 文件中构成类的静态和实例方法等类的成员的字节码指令一同加载到内存中，而后要为静态域分配存储空间并使用静态块对其进行初始化（如果有的话）。在上面例子中，类加载后，所有成员（包括fun和staticfun）的字节码指令均在内存中了，随时等待着调用，并且静态域 s 所占用的存储空间也用空引用初始化好了。

从内存上来看，当第一次调用 getInstance() 方法时会创建此类的唯一实例（所谓的单例出现），其实也可以在声明 s 时 new 它的唯一实例，将实例化延后是为了避免类加载后实例使用前内存的浪费。

静态方法线程是安全的，所谓线程安不安全是指当多个线程同时操作一个对象（通过调用它的实例方法）时是否会造成对象内部状态的破坏，而静态方法不是用来对实例进行操作的，所以一般不用考虑线程同步。如果在静态方法中读写文件，此时如果多个线程同时通过调用此静态方法对文件操作肯定会造成文件内容的破坏，但这不是线程没同步造成的，因为没有对象的状态被破坏。但可以利用线程同步机制防止上面情况的发生。
4.从生命周期上来看，静态方法的类会在代码编译的时候就被加载，静态方法中产生的对象，会随着静态方法执行完毕而释放掉，而且执行类中的静态方法时，不会实例化静态方法所在的类。如果用单例模式, 产生的那一个唯一的实例，会一直在内存中，不会被GC清除的(原因是静态的属性变量不会被GC清除)，除非整个应用退出了JVM （所以实际应用中更多的是静态方法中获取单例）

单例模式是利用唯一的实例保存系统的状态，提供的实例方法也是为了对这个唯一的实例进行操作，而静态方法多是一些工具方法，Math 类中的静态方法就是一个典型的例子，如果仅仅是想不自己创建类的实例就可以调用到某些方法来完成一定的操作，那完全没必要也不应该使用单例模式。

从执行效率上看：静态方法与实例方法，在加载时机和占用内存上，静态方法和实例方法是一样的，在类型第一次被使用时加载。调用的速度基本上没有差别。但是从日志打印来看，个人感觉还是静态方法在执行效率上快一点。

静态方法是面向过程的，而非面向对象的编程思想

2.选择

那怎么选择到底是用静态还是用单例呢？
继续分析上述例子，service的实例化依赖于 Cache的加载完成，换句话说，就是它依赖外部资源。
那么我们可以这样进行抉择：
2.1.如果依赖于外部资源，那么应该使用单例模式
2.2.如果仅仅是个工具类，是个面向过程的函数，那么可以使用static
2.3.如果你的方法有重载的可能性，那么用单例，否则用static