java学习day17--API-单例设计模式

单例设计模式

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

• 优点:
  • 在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。
  • 避免对资源的多重占用（比如写文件操作）。
• 缺点:
  • 没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

原理

通过私有构造使对象不能被new, 在类内通过一个静态方法来创建对象, 这个静态方法就是一个访问它的全局访问点。

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
 */

RunTime.java

package java.lang;
public class Runtime {
    //1、创建静态的全局唯一的对象
    private static Runtime currentRuntime = new Runtime(); 
    //2、私有构造方法，不让外部来调用
    /** Don't let anyone else instantiate this class */
    private Runtime() {}
    //3、通过自定义的静态方法获取实例
    public static Runtime getRuntime() {
        return currentRuntime;
    }
}

饿汉式

class MySingle {
    // 私有化构造方法
    private MySingle() {}

    // 在类地内部, 创建对象, 优先加载到内存
    private static MySingle my = new MySingle();

    // 提供公共的全局访问点
    public static MySingle getInstance() {
        return my; // 把自己创建好的对象返回给外界调用的位置
    }
}

饿汉式没有安全隐患, 因为在多线程编程中, 当会被多条语句操作时, 共享数据才有隐患

懒汉式

面试重点:延迟加载+线程不安全

class MySingle2 {
    // 私有构造
    private MySingle2() {} 
    // 在类地内部, 创建对象
    private static MySingle2 my;
    // 提供公共的全局访问点
    public static MySingle2 getInstance() {
        if (my == null) {
            my = new MySingle2(); // 延迟加载
        }
        return my;
    }
}

懒汉式存在安全隐患, 有多条语句操作共享数据, 如果是多线程编程一定有隐患 --

解决办法: 加线程锁, 如下代码: (把getInstance()方法用synchronized修饰即可)

class MySingle2 {
    private MySingle2() {} // 私有构造
    private static MySingle2 my;
    public synchronized static MySingle2 getInstance() {
        if (my == null) {
            // 延迟加载, 什么时候用, 什么时候创建
            my = new MySingle2(); 
        }
        return my;
    }
}

测试单例模式

通过懒汉式或饿汉式创建均可

public static void main(String[] args) {
    MySingle2 my = MySingle2.getInstance();
    MySingle2 my1 = MySingle2.getInstance();
    MySingle2 my2 = MySingle2.getInstance();

    System.out.println(my);
    System.out.println(my1);
    System.out.println(my2);
}

结果: 地址值相等

总结

懒汉式和饿汉式

1. 区别:

   创建对象的时机不同, 饿汉式不管你什么时候需要都第一时间把对象加载进内存, 静态的资源比较占内存

2. 懒汉式好处:

   可以延迟加载, 需要这个对象时才会创建对象. 省内存

3. 面试点:

   • 懒汉式延迟加载的思想 (可参考懒汉式好处和上面代码示例)
   • 懒汉式线程安全的解决方案 (加线程锁, 上面有代码示例)