设计模式之单例模式

最新推荐文章于 2024-11-12 09:25:54 发布

微光瞬间

最新推荐文章于 2024-11-12 09:25:54 发布

阅读量214

点赞数

分类专栏：设计模式文章标签：设计模式优化

本文链接：https://blog.csdn.net/qq_31782957/article/details/59117760

版权

设计模式专栏收录该内容

3 篇文章 0 订阅

订阅专栏

设计模式之单例模式

单例模式：保证一个类有且仅有一个实例，并提供一个访问它的全局访问点
单例模式的特点：
　　1）：构造方法私有化；
　　2）：内部产生该类对象的实例，并将其封装为private static；
　　3）：定义静态方法返回内部定义的实例。

本博文将单例模式分为以下五种：
　　１）饿汉式（饥汉式）
　　２）懒汉式
　　３）简单优化的懒汉式
　　４）最终优化的懒汉式
　　５）JDK1.5之前的单例模式

接下来会逐一介绍：
　　１）饿汉式（饥汉式）

/**
 * @function 23种设计模式之一:单例模式
 * @describe 单例模式实现之"饿汉式"(或"饥汉式")
 *            优点 : 不存在多线程访问临界资源的问题，避免了synchronized同步所造成的性能问题
 *            缺点 : 类加载时就需要实例化对象(不论你是否使用到这个实例)，会提前占用系统资源，直到该类被摧毁
 * */
public class SingletonTest_01 {
    //私有构造方法(防止通过 new SingletonTest_01()去实例化)
    private SingletonTest_01(){

    }

    //将自身对象的实例设置为本类的属性，并添加static和final
    private static final SingletonTest_01 instance = new SingletonTest_01(); 

    //静态方法返回该类实例
    public SingletonTest_01 getInstance(){
        return instance;
    }   
}

　　２）懒汉式

/**
 * @function 23种设计模式之一:单例模式
 * @describe 单例模式实现之"懒汉式"
 *            优点 : 与饿汉式相比，此种方法只在内部声明对象，尚未实例化，减少了对系统资源的浪费
 *            缺点 : 面临多线程访问临界资源的问题，可能产生多个实例，严重违背单例模式的本意
 * */
public class SingletonTest_02 {
    //私有构造方法(防止通过 new SingletonTest_02()去实例化)
    private SingletonTest_02(){

    }

    //将自身对象的实例设置为本类的属性，但该实例尚未实例化(注意此时没有声明final关键字)
    private static SingletonTest_02 instance;

    //延迟实例化操作 ，但假如进行多线程操作，可能会产生多个实例
    public static SingletonTest_02 getInstance(){
        if(instance == null){
            instance = new SingletonTest_02();
        }
        return instance;
    }
}

　　３）简单优化的懒汉式

/**
 * @function 23种单例模式之一:单例模式
 * @describe 单例模式实现之"简单优化的懒汉式"
 *            优点 : 使用synchronized同步getInstance()方法，避免可能会产生多个实例的问题
 *            缺点 : 每次调用getInstance()方法时都需要synchronized同步操作，影响程序的性能
 * */
public class SingletonTest_03 {

    //提供该类私有构造方法(防止通过 new SingletonTest_03()去实例化)
    private SingletonTest_03(){

    }

    //将自身对象的实例设置为本类的属性，但该实例尚未实例化(注意此时没有声明final关键字)
    private static SingletonTest_03 instance;


     //定义一个静态方法(只有在调用此方法时，才会实例化该对象，但每次调用该方法时
     //都需要synchronized同步操作，同样也会影响性能)
    public static synchronized SingletonTest_03 getInstance(){
        if(instance == null){
            instance = new SingletonTest_03();
        }
        return instance;
    }
}

　　４）最终优化的懒汉式

/**
 * @function 23种设计模式之一:单例模式
 * @describe 单例模式实现之"最终优化的懒汉式"
 *             解决了关于多线程访问时，出现多个实例的问题，同时提高程序的执行效率
 * */
public class SingletonTest_04 {

    //定义私有构造方法，为了防止通过new SingletonTest_04()来实例化
    private SingletonTest_04(){

    }


    //定义一个静态变量，尚未进行实例化(注意没有使用final关键字，使用volatile关键字
    //保证了多线程访问时instance变量的可见性，避免了instance初始化时
    //其他变量属性还没赋值完时，被另外线程调用的问题)
    private static volatile SingletonTest_04 instance;

    //定义一个静态方法，返回该类的实例
    public SingletonTest_04 getInstance(){
        //假如对象已经实例化，不再执行同步代码块，提高执行效率
        if(instance == null){
            //对象尚未初始化时，使用同步代码块，保证多线程访问时对象不会被重复创建
            synchronized(SingletonTest_04.class){
                //当尚未实例化该对象时，实例化instance
                if(instance == null){
                    instance = new SingletonTest_04();
                }
            }
        }
        return instance;
    }
}

　　５）JDK1.5之前的单例模式

/**
 * @function 针对JDK1.5之前单例模式的解决方案
 * @describe JDK1.5之前对于volatite关键字的说明不是很明确，所以使用私有静态内部类来解决
 *            具体如此的设计的原因不是很明确，可能是能力不够，但会在后面附上参考文章的地址
 * */
public class SingletonTest_05 {

    //提供私有构造方法(防止通过new SingletonTest_05()来实例化)
    private SingletonTest_05(){

    }

    //定义私有静态内部类
    private static class SingletonInstance{
        private static final SingletonTest_05 instance = new SingletonTest_05(); 
    }

    //定义一个静态方法，返回内部类中的instance
    public static SingletonTest_05 getInstance(){
        return SingletonInstance.instance;
    }
}