设计模式之单例模式

目录

单例模式

优点:

缺点:

举例:

实现方式:

        1.饿汉式

        2.懒汉式 线程不安全

        3.懒汉式,线程安全

        4.双重锁

        5.静态内部类

        6.枚举

总结

---

单例模式

        属于创建型模式

        意图:保证一个类仅有一个实例,并提供一个访问它的全局访问点

        主要解决:一个全局使用的类频繁的创建与销毁

        关键代码:构造函数私有化

优点:

        1.在内存里只有一个实例,减少了内存的开销

        2.避免了对资源的多重占用

缺点:

        没有接口,不能继承,与单一职责原则冲突

举例:

public class SingleObject{    //此举例为饿汉式实现
    
    //创建SingleObject 的一个对象
    private static SingleObject single=new SingleObject();

    //构造函数私有化,保证该类不会被实例化
    private SingleObject(){};

    //获取唯一可用的对象
    public static SingleObject getSing(){
        return single;
    }
}

实现方式:

        1.饿汉式

                是否 Lazy 初始化:否

                是否多线程安全: 是

                优点: 没有加锁,执行效率会提高

                缺点:类加载时就初始化,浪费内存

//实现​
public class SingleObject{    
    
    //创建SingleObject 的一个对象
    private static SingleObject single=new SingleObject();

    //构造函数私有化,保证该类不会被实例化
    private SingleObject(){};

    //获取唯一可用的对象
    public static SingleObject getSing(){
        return single;
    }
}

        2.懒汉式 线程不安全

                是否 Lazy 初始化: 是

                是否多线程安全: 否

//实现
public class SingleObject{
    
    private static SingleObject single;
    private SingleObject(){};
    
    public static SingleObject getSingle(){
        if(single == null){
            single=new SingleObject();
        }
        return single;
    }
}

        3.懒汉式,线程安全

                是否 Lazy 初始化: 是

                是否多线程安全: 是

                优点: 第一次调用的时候才初始化,避免内存的浪费

                缺点:必须加锁 synchronized 才能保证单例,但加锁会影响效率

//实现
public class SingleObject{
    
    private static SingleObject single;

    private SingleObject(){};

    public static synchronized SingleObject getSingle(){
        if(single == null){
            single=new SingleObject();
        }
        return single;
    }
}

        4.双重锁

                是否 Lazy 初始化: 是

                是否多线程安全: 是

                要求: JDK版本1.5以上

//实现
public class SingleObject{

    private static SingleObject single;

    private SingleObject(){};

    public static SingleObject getSingle(){
        if(single == null ){
            synchronized(SingleObject.class){
                if(single == null){
                    single == new SingleObject();
                }
            }
        }        
        return single;
    }
}

        5.静态内部类

                是否 Lazy 初始化: 是

                是否多线程安全: 是

//实现
public class SingleObject{
    
    private static class Singleon{
        private static final SingleObject single=new SingleObject();
    }

    private SingleObject(){}

    public static final SingleObject getSingle(){
        return Signleon.single;
    }
}

        6.枚举

                是否 Lazy 初始化: 否

                是否多线程安全: 是

//实现
public enum SingleObject{
    single;
    public void getMethod(){
    }
}

总结

        一般情况下,不建议使用 第2种 和 第3种懒汉方式,建议使用第1种饿汉方式.只有在明确实现lazy loading 效果时,才会使用第5种方式,如果涉及到反序列化创建对象时,可以尝试使用第6种枚举方式.如果有其他特殊的需求,可以考虑第4种双重锁方式