单例模式

一，饿汉式

优点：线程安全，实现简单。

缺点：类加载时就初始化了，没有实现懒加载。

public final class HungrySingleTon {

private static final HungrySingleTon instance = new HungrySingleTon();

private HungrySingleTon() {
    if (instance != null) {
        throw new IllegalStateException("实例已经初始化！");
    }
}

public HungrySingleTon getInstance() {
    return instance;
}

}
二，饿汉式（线程不安全的形式）

优点：懒加载。

缺点：线程不安全。

public final class SingleTonSecond {

private static SingleTonSecond singleTonSecond;

private SingleTonSecond() {
    if (singleTonSecond!= null) {
        throw new IllegalStateException("实例已经初始化！");
    }
}

public static SingleTonSecond getInstance() {
    if (null == singleTonSecond) {
        singleTonSecond = new SingleTonSecond();
    }
    return singleTonSecond;
}

}
三、懒汉式（线程安全）

优点：懒加载、线程安全。

缺点：每次获取单例都要锁定整个方法，性能较差

public final class LazySingleTonSafe {

private static volatile LazySingleTonSafe instance;

private LazySingleTonSafe() {
    if (instance != null) {
        throw new IllegalStateException("实例已经初始化！");
    }
}

public synchronized static LazySingleTonSafe getInstance() {
    if (null == instance) {
        instance = new LazySingleTonSafe();
    }
    return instance;
}

}
四、双重检查懒汉式单例

优点：线程安全，只在第一次获取单例时锁定了单例对象。

public final class DoubleCheckedLockSingleTon {

private static volatile DoubleCheckedLockSingleTon instance;

private DoubleCheckedLockSingleTon() {
    if (instance != null) {
        throw new IllegalStateException("实例已经初始化！");
    }
}

public static DoubleCheckedLockSingleTon getInstance() {

    if (null == instance) {
        synchronized (DoubleCheckedLockSingleTon.class) {
            if (null == instance) {
                instance = new DoubleCheckedLockSingleTon();
            }
        }
    }
    return instance;
}

}
五、静态内部类方式-推荐！

优点：线程安全，懒加载，效率高静态内部类的凡是在单例类在被JVM加载到内存时并不会立即实例化，而是在第一次调用的getInstance（）方法时才会将SingleTonFifthInner类加载到内存，从而实例化SingleTonFifthInner的静态属性。JVM在类加载阶段是同步加锁的，因此JVM替我们保证了在同一时刻只会有一个内部类被加载。 

public final class StaticInnerClassSingleTon {

private StaticInnerClassSingleTon() {

}

private StaticInnerClassSingleTon getInstance() {
    return StaticInnerClassSingleTonHolder.instance;
}

private static class StaticInnerClassSingleTonHolder {

    private static final StaticInnerClassSingleTon instance = new StaticInnerClassSingleTon();
}

}
六，枚举类型实现单例模式

public class SingleTonSixth {

private SingleTonSixth(){

}

public static SingleTonSixth getInstance(){
    return SingleTonEnum.ISNTANCE.getInstancee();
}

private static enum SingleTonEnum{
    ISNTANCE;

    private  SingleTonSixth singleTonSixth;

    private  SingleTonEnum(){
        singleTonSixth=new SingleTonSixth();
    }

    private  SingleTonSixth getInstancee(){
        return singleTonSixth;
    }

}