java设计模式之-单例模式

java设计模式之-单例模式

什么是单例：单例就是在一个应用期间有且只有一个实例（不管有多少人调用它，拿到的实例都是同一个）。

一、单例模式-饿汉式

public class Singleton01 {
    private static final Singleton01 singleton = new Singleton01();
    //私有化构造
    private Singleton01() {}
    public static Singleton01 getSingleton() {
        return singleton;
    }
}

public class Singleton02 {
    private static Singleton02 singleton;
    static {
        singleton=new Singleton02();
    }
    private Singleton02() {}
    public static Singleton02 getSingleton() {
        return singleton;
    }
}

饿汉式非懒加载，也就是说饿汉式会在类加载的时候就实例化。但是不能否认的是如果该类中还有其他方法，而我们调用的是其他的方法且至始至终都没有调用过实例化好的单例，那实例化好的单例是多余的，不可避免的造成了内存的浪费。但是同样对于多线程来说，饿汉式是不需要考虑线程安全的，因为他们有且只能创建出一个单例，而不像懒汉式那样，会出现非单例的情况。

二、单例模式-懒汉式

public class Singleton03 {
    private static Singleton03 singleton;
    private Singleton03() {}
    public static Singleton03 getSingleton() {
        if(singleton==null)
            singleton=new Singleton03();
        return singleton;
    }
 9 }

懒汉式与饿汉式相比，懒汉式是在方法内进行实例化对象的，只是多加了一重判断。而且这种方法在多线程条件下也同样可能出现多个实例的情况。出现这种情况的原因就是该线程是非安全的，那么有人一定会说加上线程同步锁。确实，线程同步锁可以解决上诉问题，但是同样的，线程同步同时也会带来效率低下的问题。所以我觉得线程同步还是摒弃掉吧

三、静态内部类

public class Singleton05 {
    
    private Singleton05() {}
    public static class ASingloten{
        private static final Singleton05 INSTANCE = new  Singleton05();
    }
    public static Singleton05 getSingleton() {
        return ASingloten.INSTANCE;
    }
}

这种方式和饿汉式有点类似，但是饿汉式并没有懒加载机制，他会在类加载的时候实例化。而静态内部类不会则不会在类加载的时候实例化，他会在调用的时候才去实例化。

四、枚举实现

public enum Singleton06 {
    INSTANCE;
    public void doSome() {
        //System.out.println(">>>>>>>>>>>>>>");
    }
}

枚举是在JDK1.5加入的，理论上讲枚举我们可以把它看成是静态常量，所以他可以避免多线程出现的特殊情况。枚举这种方式我还是比较推荐的