单例模式-Java

饿汉、懒汉、双重校验锁及其修正、静态内部类、枚举，线程安全性以及原因

单例模式有以下特点：

1、单例类只能有一个实例。

2、单例类必须自己创建自己的唯一实例。

3、单例类必须给所有其他对象提供这一实例。

饿汉式-立即加载

public class SingleTon {
    private static SingleTon singleTon = new SingleTon();
    private SingleTon(){}
    public static SingleTon getInstance(){
        return singleTon;
    }
}

分析：
类初始化时就进行创建对象，但是不管之后是否使用这个对象，该对象都会占用内存资源。
是线程安全的，可用于多线程
为什么是线程安全的？
由于实例早已加载，多个线程同时访问getInstance时不会出现问题。

懒汉式-延迟加载

public class SingleTon2 {
    private static SingleTon2 singleTon2 = null;
    private SingleTon2(){}
    public SingleTon2 getInstance(){
        if (singleTon2 == null){
            singleTon2 = new SingleTon2();
        }
        return singleTon2;
    }
}

分析：
在需要使用该类实例时才进行加载，能够节省内存，在第一次访问getInstance( )方法时会有些慢（需创建类），之后无影响。
不是线程安全的。
为什么？当singleTon2为null时，如果多个线程同时访问getInstance( )，则都会进入if语句，就会创建多个实例，破坏了单例模式规则。

懒汉式改进版-双重校验锁

public class SingleTon3 {
    private static SingleTon3 singleTon3 = null;
    private SingleTon3(){}
    public static SingleTon3 getInstance(){
        if (singleTon3 == null){
            synchronized (SingleTon3.class){
                if (singleTon3 == null){
                    singleTon3 = new SingleTon3();
                }
            }
        }
        return singleTon3;
    }
}

分析：
改进了懒汉式线程不安全的问题，但是同步还是有点性能消耗。
为什么？当多个线程同时访问getInstance( )方法时，若 singleTon3不为null，则可以直接返回，否则都进入第一个if语句，接下来有一个同步代码块，所以进入if语句的多个线程会“排队”执行，第一个线程进入同步块后，创建了singleTon3实例，所以当接下来的线程都不会执行第二个if语句。
缺点：指令重排问题。

懒汉式改进版-静态内部类

public class SingleTon4 {
    private static class Inner{
        private static final SingleTon4 INSTANCE = new SingleTon4();
    }
    private SingleTon4(){}
    public SingleTon4 getInstance(){
        return Inner.INSTANCE;
    }
}

分析：
延迟加载，线程安全。
分析：
巧妙之处在于静态内部类，内部类（不论是静态内部类还是非静态内部类）都是在第一次使用时才会被加载。 外部类不调用 getInstance（）时候内部类是不会加载的，所以实现了延迟加载的功能，并且是线程安全的。

总分析

通过Java反射机制是能够实例化构造方法为private的类的，基本上会使所有的Java单例实现失效。