单例模式

---

第一种 懒汉 线程不安全

public class Singleton {

    private static Singleton instance;

    private Singleton() {
    }
    //静态工厂方法
    public static Singleton getInstance() {

        if (instance == null)
            instance = new Singleton();
        return instance;
    }
}

这种写法lazy loading很明显，等到第一次使用时再创建实例，因此称为懒汉。问题是该写法没有考虑线程安全问题，并发环境下可能会出现多个Singleton实例，在多线程下不能正常工作。但是提供了单例的基本思路：构造器私有。将构造器限制为private能够避免类在外部被实例化。
以下三种是对懒汉模式的改造，保证线程安全

第二种 懒汉 synchronized 保证线程安全

public class Singleton {

    private static Singleton instance;

    private Singleton() {
    }
    //静态工厂方法 采用同步
    public static synchronized Singleton getInstance() {

        if (instance == null)
            instance = new Singleton();
        return instance;
    }
}

该写法能够保证线程安全，但是效率很低。不论instance是否被实例化，当调用getInstance获取实例的时候，都会加锁。

第三种 懒汉 双重校验锁

public class Singleton {

    private volatile static  Singleton instance;

    private Singleton() {
    }

    public static Singleton getInstance() {

        if (instance == null) {//第一次判断
            synchronized (Singleton.class) {
                if (instance == null)//第二次判断
                    instance = new Singleton();
            }
        }

        return instance;
    }
}

1.为何synchronized不加在getInstance方法上，而是移到方法体内？
将synchronized写到方法体内，是为了降低锁的粒度。考虑存在这样的情况：Singleton类中还会存在其他的static方法如f()，当synchronized直接加到getInstance方法上的时候，就会对整个Singleton类加锁，其他程序想要调用类中f(),无法执行只能等待getInstance方法执行完再调用。
将synchronized写进方法内，只有instance实例未被实例化的时候，才会将整个Singleton类进行加锁。所以将synchronized写到方法体内是为了不影响其他方法的调用。
2.为何会进行两次instance==null的判断？去掉第一个可以吗？去掉第二个可以吗？
去掉第一个也可以，但是不推荐。如果去掉第一个if判断，那么当调用getInstance方法的时候，无论instance是否被实例化，都会对整个类进行加锁，不去掉第一个的话，只有instance== null的时候，才会对整个类加锁。
去掉第二个不可以。很可能在第一个if判断的时候，instance== null成立，等到执行到同步块中的时候，instance可能已经被其他线程实例化了。所以需要再加一次判断。
3.关于volatile的作用？
volatile的作用是避免指令的重排序。初始化一个实例：instance= newInstance()在字节码中有四个步骤：
1.申请内存空间
2.初始化默认值
3.执行构造器方法
4.连接引用和实例
这四个步骤后面两个可能会出现重排序，1234或者1243，1243出现的结果就是造成未初始化完全的对象会被发布然后被使用。volatile可以禁止指令的重排序，从而避免这个问题。

第四种 懒汉 静态内部类

public class Singleton {

    private static class LazyHolder {

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

    private Singleton() {}

    public static final Singleton getInstance() {

        return LazyHolder.INSTANCE;
    }
}

第五种 饿汉 非延迟加载

public class Singleton {
    //加载类的时候会初始化static的instance，
    private static Singleton instance = new Singleton();

    private Singleton() {}

    public static Singleton getInstance() {
        return instance;
    }
}

instance在类装载时就被实例化，因此是天生安全。

第六种 饿汉

public class Singleton {

    private static Singleton instance;

    static {
        instance = new Singleton();
    }

    private Singleton() {
    }

    public static Singleton getInstance() {
        return instance;
    }
}

该种写法与第五种类似，同样都是在类初始化的时候创建静态对象，因此也是线程安全的。

第七种 枚举

public enum Singleton {

    INSTANCE;
}

枚举实现单例模式，不仅可以避免多线程问题，还可以防止反序列化建立新对象。枚举单例模式有点类似饿汉模式，没有实现lazy loading。

---

饿汉和懒汉的区别：
饿汉保证类一旦加载完成，就把单例实例化，等到getInstance()时，单例已经存在。饿汉天生线程安全，因此可直接用于多线程。
懒汉顾名思义，lazy loading为 延迟加载，等到getInstance()时，再去实例化单例。
懒汉本身不是线程安全的，但是可以通过加同步，静态内部类，双重锁校验的方式，人为实现线程安全。

资源加载的性能：
饿汉模式下当类加载完成后，也完成了单例的实例化，单例就会存在于内存中，不管后面会不会用到，都会占用一定内存。如果该单例占用资源很多的情况下，采用饿汉模式，会导致性能降低。但是由于单例已经初始化完成，因此在第一次调用的时候速度会非常快。
懒汉模式下，延迟加载，对于占用很多资源的单例比较实用。等到使用该单例时再进行加载，会导致性能延迟。

从速度和反应角度看，饿汉模式较优；从资源利用率看，懒汉模式较优。