JAVA 设计模式之单例设计模式

前言

本人发布的一系列资料都是学习备份使用，以及方便日后复习，随着技术的不断提升，每个文章都会持续添加内容，或者是扩展文章，本是秉承着分享的心态，互相学习，互相提升，也希望提出更好的意见，以及学习思路，欢迎留言，欢迎评论，谢谢！！

设计模式（Design pattern）

代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。
JAVA一共有23种设计模式,我们今天首先来学其中一种:单例设计模式

单例设计模式

单例模式可以说是大多数开发人员在实际中使用最多的，常见的Spring默认创建的bean就是单例模式的。
单例模式有很多好处，比如可节约系统内存空间，控制资源的使用。
其中单例模式最重要的是确保对象只有一个。
简单来说，保证一个类在内存中的对象就一个。
RunTime就是典型的单例设计，我们通过对RunTime类的分析，一窥究竟。

RunTime单例设计源码剖析

 /**
 * Every Java application has a single instance of class
 * <code>Runtime</code> that allows the application to interface with
 * the environment in which the application is running. The current
 * runtime can be obtained from the <code>getRuntime</code> method.
 * <p>
 * An application cannot create its own instance of this class.
 *
 * @author  unascribed
 * @see     java.lang.Runtime#getRuntime()
 * @since   JDK1.0
 */
public class Runtime {
	//2.创建静态的全局唯一的对象
	private static Runtime currentRuntime = new Runtime();

	//1.私有化构造方法,不让外部来调用
    /** Don't let anyone else instantiate this class */
    private Runtime() {}
    
	//3.通过自定义的静态方法获取实例
    public static Runtime getRuntime() {
        return currentRuntime;
}
}

通过分析,底层的实现思路一共分为了3个步骤:

• 对本类构造方法私有化,防止外部调用构造方法创建对象
• 创建全局唯一的对象,也做私有化处理
• 通过自定义的公共方法将创建好的对象返回(类似封装属性后的getXxx() )

那我们不妨自己尝试着来写写单例模式

练习:单例设计模式1-饿汉式实现方式

创建包: cn.tedu.design
创建类: Singleton1.java

package cn.tedu.design;
/*本类用于实现单例设计模式实现方案1:饿汉式*/
public class Singleton1 {
    public static void main(String[] args) {
        //5.在main()中，不通过对象，直接通过类名，调用静态方法
        MySingle single1 = MySingle.getSingle();
        MySingle single2 = MySingle.getSingle();
        //6.用==检验是否是同一个对象
        System.out.println(single1 == single2);//true
        System.out.println(single1);
        System.out.println(single2);
    }
}
//0.创建自己的单例程序
class MySingle{
    //1.提供构造方法，并将构造方法私有化
    /*1.构造方法私有化的目的:为了防止外界随意创建本类对象*/
    private MySingle(){ }

    //2.创建本类对象，并将对象也私有化
    //4.2由于静态资源只能调用静态资源，所以single对象也需要设置成静态
    private static MySingle single = new MySingle();

    //3.提供公共的访问方式，返回创建好的对象
    //4.1为了不通过对象，直接调用本方法，需要将本方法设置为静态
    public static MySingle getSingle(){
        return single;
    }
}

练习:单例设计模式2-懒汉式实现方式

创建包: cn.tedu.design
创建类: Singleton2.java

package cn.tedu.design;
/*本类用于实现单例设计模式优化实现方案2:懒汉式
* 关于单例设计模式的两种实现方式：
* 1.饿汉式：不管你用不用这个类的对象，都会直接先创建一个
* 2.懒汉式：先不给创建这个类的对象，等你需要的时候再创建--延迟加载的思想
* 延迟加载的思想：是指不会在第一时间就把对象创建好占用内存
*               而是什么时候用到，什么时候再去创建对象
* 3.线程安全问题：由于我们存在唯一的对象single2,并且多条语句都操作了这个变量
*   如果将程序放到多线程的环境下，就容易出现数据安全的问题，所以解决方案：
*   1) 将3条语句都使用同步代码块包裹，保证同步排队的效果
*   2) 由于getSingle2()只有这3条语句，所以也可以将本方法设置为同步方法*/
public class Singleton2 {
    public static void main(String[] args) {
        //5.调用方法查看结果
        MySingle2 single1 = MySingle2.getSingle2();
        MySingle2 single2 = MySingle2.getSingle2();
        System.out.println(single1 == single2);
        System.out.println(single1);
        System.out.println(single2);
    }
}
//0.创建自己的单例程序
class MySingle2{
    //6.2创建一个静态的唯一的锁对象
    static Object o = new Object();
    //1.私有化本类的构造方法
    private MySingle2(){ }
    //2.创建的是本类对象的引用类型变量，用来保存对象的地址值，默认值是null
    private static MySingle2 single2 ;
    //3.提供公共的get方法
    synchronized public static MySingle2 getSingle2(){
        //4.判断之前是否创建过对象，之前创建过就直接走return
        //之前如果没有创建过，才走if，创建对象并将对象返回
        //6.有共享数据+多条语句操作数据，所以尽量提前处理，避免多线程数据安全隐患
        //6.1 解决方案1：加同步代码块
        //6.2 解决方案2：将本方法getSingle2()设置为同步方法
        //因为这个方法里所有的语句都需要同步
        synchronized (o) {//静态方法中使用的锁对象也得是静态的
            if (single2 == null) {//single2还是默认值，说明之前没有创建过对象
                single2 = new MySingle2();//没创建过才创建，并赋值给single2
            }
            return single2;
        }
    }
}

总结

单例设计模式方案1-饿汉式

1. 定义一个自己的单例类
2. 将本类的构造方法私有化
3. 创建本类的对象，也把对象私有化
4. 提供公共的get方法，将刚刚创建好的唯一的对象返回
   注意：get方法与要返回的对象都得是静态的

单例设计模式方案2：-懒汉式

1. 定义一个自己的单例类
2. 将本类的构造方法私有化
3. 先定义一个成员变量，用来保存对象的地址值
4. 提供公共的get方法，当用户调用此方法时，才说明用户需要这个对象
   这个时候就可以创建本类唯一的对象了，并将刚刚创建好的唯一的对象返回
   注意：在get（）中创建对象前需要加一个判断，只有之前没创建过，才会创建一次
   所以，当第2~n次调用get（）时，直接把第1次创建好的对象的地址值返回

关于单例设计模式的两种实现方式：

1. 饿汉式：不管你用不用这个类的对象，都会直接先创建出来
2. 懒汉式：先不给你创建这个类的对象，等你需要的时候再创建 --延迟加载的思想

延迟加载的思想：是指不会再第一时间就把对象创建好占用内存
而是什么时候用到，什么时候再去创建