单例模式并不简单

单例模式常见的实现方式有懒汉式和饿汉式两种（不知道谁发明的这糙名字emm...）直接贴代码如下：

 1.Eagerly initialized

/**
* 不可变类其实例不能被修改； 不可变对象，本质上是线程安全的； 
*/
public final class EagerlyMan {
    // 将域定义为final，可以确保对实例的引用在线程传递中的不可变
    private static final EagerlyMan INSTANCE = new EagerlyMan();

    private EagerlyMan() {}

    // 使用静态工厂取代导出公有的静态final域，可以提供更多的灵活性
    public static EagerlyMan getInstance() { return INSTANCE; }

}

1. static 关键字可以起到两个重要作用： 

①、方便类在没有创建对象的情况下调用方法或字段（必须是static的）;

②、被static修饰的字段或代码块当且只当类加载的时候就初始化，static字段在内存中只有一个副本，被所有的对象共享

2. Lazily initialized需要同步机制

public final class LazyMan {

    private static LazyMan instance;

    private LazyMan() {
        if (instance != null) { 
        // 享有特权的客户端可以调用AssessibleObject.setAccessinle方法通过反射调用私有构造器，为抵御这种方式可以抛出一个异常
            throw new IllegalStatExcaption();
        }
    }
　　// 避免延迟初始化产生的竞态条件，使用同步代码块保证原子性和可见性
    public static synchronized LazyMan getInstance() {
        if (instance == null) {
            instance = new LazyMan();
        }
        return instance;
    }
}

在这两种习惯模式中（正常初始化和延迟初始化）应用到非静态域上也是一样的

3. 双重检查初始化

public final class SuperLazyMan {

    private volatile SuperLazyMan instance;

    private SuperLazyMan() {
        if (instance != null) {
            throw new IllegalStateException();
        }
    }

    public SuperLazyMan getInstance() {
         // 线程私有的局部变量, 确保实例域被初始化后只读取一次，可以提升性能
        SuperLazyMan result = instance; 

        if (result == null) {
            synchronized (this) {
                result = instance;
                if (result == null) {
                    /** 这段是非原子操作，大致做了3件事情： 
                    * 1.给实例分配内存 2.构造器初始化 3.将instance对象指向分配的内存空间
                    * 由于指令的重排序，3可能会在2之前执行， 因此instance必须加上volatile，禁止指令重排序
                    */
                    result = instance = new SuperLazyMan();
                }
            }
        }
        return result;
    }
}

4.使用内部类延迟初始化

public final class DemandHolderLazyMan {

    private DemandHolderLazyMan() {}
    
    public static DemandHolderLazyMan getInstance() {
        return HelperHoler.INSTANCE;
    }

    private static class HelperHoler {

        private static final DemandHolderLazyMan INSTANCE = new DemandHolderLazyMan();
    }
}

 总结：

大多数的域都应该正常地进行初始化，而不是延迟初始化。如果是为了达到性能目标而必须延迟初始化一个域，对于实例域，就使用双重检查模式；对于静态域，则使用内部类延迟初始化。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　—————— 摘自Joshua Bloch "Effective Java, Second Edition"