java单列标准写法

单例模式使用volatile保证有序性的例子

public class Singleton {
    public static volatile Singleton singleton;

    /**
     * 构造函数私有，禁止外部实例化
     */
    private Singleton() {};

    public static Singleton getInstance() {
        if (singleton == null) {
            synchronized (singleton) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

先要了解对象的构造过程，实例化一个对象其实可以分为三个步骤：

分配内存空间。

1. 初始化对象。
2. 将内存空间的地址赋值给对应的引用。
3. 但是由于操作系统可以对指令进行重排序，所以上面的过程也可能会变成如下过程：

• 分配内存空间。
• 将内存空间的地址赋值给对应的引用。
• 初始化对象

如果是这个流程，第一个线程singleton = new Singleton();时候可能将一个未初始化的对象引用暴露出来（即把一个未初始化的对象的引用地址赋值给引用变量），第2个线程在第一个if (singleton == null) 时判断对象不是空了，直接返回一个未初始化的对象

我们需要将变量设置为volatile类型的变量不让编译器和cpu不做排序优化

单列类懒加载可以使用内部类替代

/**
 * 只有调用TestTemp类的InnerLazyClass内部类的信息时才初始化内部类，
 * 调用类自身的信息不会初始化内部类
 */
class TestTemp {
    public static void main(String[] args) throws InterruptedException {
        Integer i=new Integer(1);
        System.out.println(new TestTemp().toString());//不初始化内部类
        System.out.println(InnerLazyClass.innerLazyClass);//初始化内部类，实现懒加载

    }
    private static final class InnerLazyClass {
        public static InnerLazyClass innerLazyClass;
        static {
            innerLazyClass = new InnerLazyClass();
            System.out.println("InnerLazyClass");
        }
    }
}