单例设计模式与类加载顺序详解

单例设计模式几种实现 （测试所用jdk版本1.8.0_20）

第一种：

public final class SingleInstance1 {

    private static volatile SingleInstance1 singleInstance = null;
    /*
     * 必须定义，防止jvm提供默认构造函数（默认的为public）这样就失去了单例的特性，
     * 因为可以new一个实例
     */
    private SingleInstance1(){}
    public static SingleInstance1 getInstance(){
        if(singleInstance == null){
            synchronized (SingleInstance1.class) {
                if(singleInstance == null){
                    singleInstance = new SingleInstance1();
                }
            }
        }
        return singleInstance;
    }
}

这种模式是单锁，有线程安全问题 所以用两把锁

第二种：

/**
 * 
 *  说明：线程安全的单例
 *
 */
public final class SingleInstance2 {

    private static volatile SingleInstance2 singleInstance = null;

    /*
     * 必须定义，防止jvm提供默认构造函数（默认的为public）这样就失去了单例的特性， 因为可以new一个实例
     */
    private SingleInstance2() {
    }

    public static SingleInstance2 getInstance() {
        if (singleInstance == null) {
            synchronized (SingleInstance2.class){
                SingleInstance2 tmpInstance2 = singleInstance;
                synchronized (SingleInstance2.class) {
                    if (tmpInstance2 == null) {
                        tmpInstance2 = new SingleInstance2();
                    }
                    singleInstance = tmpInstance2;
                }
            }
        }
        return singleInstance;
    }
}

第三种：

/**
 * 
 * 说明：饿汉式 不是线程安全的
 *
 */
public class SingleInstance3 {
    private static SingleInstance3 singleInstance = null;
    
    private SingleInstance3(){}
    
    public SingleInstance3 getInstance3() {
        if(singleInstance == null) {
            singleInstance = new SingleInstance3();
        }
        return singleInstance;
        
    }

}

第四种：

/**
 * 
 * 说明：懒汉式  缺点：每个对象在没有使用之前就已经初始化了。这就可能带来潜在的性能问题
 * 没有使用这个对象之前，就把它加载到了内存中去是一种巨大的浪费
 */
public class SingleInstance4 {
    private static SingleInstance4 singleInstance = new SingleInstance4();

    private SingleInstance4() {
    }

    public SingleInstance4 getInstance() {
        return singleInstance;
    }

}

第五种：

/**
 * 
 *说明：线程安全 但是效率低，因为只需要创建时同步就可以了 不需要每次访问都要同步
 */
public class SingleInstance5 {
    private static SingleInstance5 singleInstance5 = null;
    private SingleInstance5() {
    }

    public static synchronized SingleInstance5 getInstance5(){
        if(singleInstance5 == null){
            singleInstance5 = new SingleInstance5();
        }
        return singleInstance5;
    }
}

第六种：

/**
 *
 *内部类静态属性（或静态块）会在内部类第一次被调用的时候按顺序被初始化（或执行）而且只会被加载一次
 *测试请看StaticInnerClassLoaderTime类
 */
public class SingleInstance6 {
    private SingleInstance6() {}
    private static class SingletonHolder {
        public final static SingleInstance6 instance = new SingleInstance6();
    }    

    public static SingleInstance6 getInstance() {
        return SingletonHolder.instance;
    }

}

StaticInnerClassLoaderTime类

public class StaticInnerClassLoaderTime {
    
    public static class Inner {
        static {
            System.out.println("TestInner Static!");
        }
        public final static StaticInnerClassLoaderTime testInstance = 
                new StaticInnerClassLoaderTime(3);
    }

    public static StaticInnerClassLoaderTime getInstance() {
        return Inner.testInstance;
    }

    public StaticInnerClassLoaderTime(int i) {
        System.out.println("Test " + i + " Construct! ");
    }
    
    
    // 类静态属性
    public static StaticInnerClassLoaderTime testOut =
            new StaticInnerClassLoaderTime(1);

    public static int value = 3;
    // 类静态块
    static {
        System.out.println("Test Static" + testOut);
    }

    public static void main(String args[]) {
        StaticInnerClassLoaderTime t = new StaticInnerClassLoaderTime(2);
        //说明静态内部类只有在调用时才会被加载 而且只会被加载一次 因此最好的单例设计模式是用静态内部类
        StaticInnerClassLoaderTime.getInstance();
        StaticInnerClassLoaderTime.getInstance();
    }

}

运行结果：

Test 1 Construct!
Test Staticcn.canon.Single.StaticInnerClassLoaderTime@15db9742
Test 2 Construct!
TestInner Static!
Test 3 Construct! 

说明：

 顺序是：父类静态属性-》父类静态代码块-》子类静态变量-》子类静态代码块-》父类非静态变量-》父类非静态代码块-》父类构造函数-》
 子类非静态变量-》子类非静态代码块-》-》子类构造函数

这样的加载顺序不是绝对的 因为静态变量和静态代码块跟声明顺序有关。

对于如果静态代码块中调用静态变量，那么静态变量必须在静态代码块前面声明；如果静态代码块中没有调用静态变量，
那么就跟顺序有关了，谁先声明谁先被加载。说白了还是顺序加载，之所以会出现“如果静态代码块中调用静态变量，
那么静态变量必须在静态代码块前面声明”，是因为变量是声明，所以出现编译错误。

应用到内部类中 静态变量和静态代码块跟声明顺序有关。 这样就可以解释你的问题了。内部类也是类。

类静态块-类静态属性这个跟顺序有关系 如果类静态属性在类静态代码块之前 那么类静态属性先初始化