Java知识点——单例模式

单例模式

1. 单例模式

1.1 要求

	当前类有且只有一个对象，一旦当前类存在一个对象之后，无法在重新创建当前类的对象。就算是你要创建，代码返回的对象依然是上一次创建的对象。
	懒汉模式，饿汉模式 

1.2 单例模式推导【懒汉】

package com.qfedu.a_single;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * SingleDog要求是一个单例类，整个代码运行周期内有且只有一个类对象
 *
 * 不可取方式:
 * @全体成员 SingleDog类使用一个单例类，我创建过对象了，你们不要搞事情
 *          红包
 * 【期望】
 *      从语法角度约束一些行为。
 *      目前创建对象过于简单，new + 构成方法组合非常easy
 * 【解决方案】
 *      private修饰构造方法
 *
 * 【问题】
 *      构造方法私有化之后，类外没有操作构造方法的权限，没办法创建对象
 * 【解决方案】
 *      1. 暴力反射
 *          暴力反射，给予构造方法操作权限，这里和没有使用private有什么区别
 *          【不合适】
 *      2. 期望
 *          类外最起码有一个对象。
 *          a. 类外没有SingleDog类对象
 *          b. 期望获取到一个SingleDog对象
 *
 *          需要方法来完成
 *              1. 该方法要求静态成员方法，没有对象，需要通过类名调用
 *              2. 类外要求使用public修饰
 *              3. 该方法需要得到一个SingleDog对象，返回值类型是SingleDog
 *              4. 方法参数为无参数，构造方法也是无参
 *              5. 方法名 getInstance
 *              public static SingleDog getInstance()
 *
 * 【问题】
 *      依然是不同对象
 *
 * 【期望】
 *      1. 调用该方法每一次调用都是new新的对象。
 *      2. 这个new得有限制，如果之前创建过对象，你就不能再new了，没有对象可以new
 *      3. 存在一个变量可以保存之前创建对象的空间首地址，并且可以持久性保存。
 *      分析：
 *          a. 需要保存SingleDog类对象空间首地址
 *                 SingleDog类型
 *          b. 该数据不能类外轻松获取
 *                 private
 *          c.
 *              (1) 静态方法可以使用
 *              (2) 有一定的持久性
 *                  static修饰成员变量
 *          private static SingleDog sd = null;
 * 【getInstance方法】
 *      需要判断
 *          判断SingleDog类型的静态成员变量 sd是否保存有之前创建的空间首地址
 *
 * 【问题】
 *      多线程情况下，存在线程抢占问题，极有可能导致当前方法被两个线程同时执行，同时
 *      创建对象
 *      com.qfedu.a_single.SingleDog@22673956
 *      com.qfedu.a_single.SingleDog@6223c513
 *
 * 【期望】
 *      在多线程情况下，也是安全的
 * 【解决方案】
 *      加锁
 *          【墙裂推荐】synchronized同步代码块
 *              使用同步代码块，用什么做锁对象?
 *              最合适的锁对象依然是Single.class
 *
 *          【墙裂推荐】synchronized同步方法
 *              static修饰静态方法的情况下，什么是锁对象?
 *                  当前SingleDog类.class字节码文件
 *                  
 *          【不推荐】Lock锁对象
 *              和以上两个方式对比?
 *              new ==> lock ==> 多出一个Lock锁空间
 *              (1) 在getInstance方法new lock是不合适，多个线程情况下
 *              可能会出现不同锁情况
 *              (2) Lock做成静态成员变量
 *                  浪费空间了！！！
 *
 *
 * @author Anonymous 2020/3/13 10:53
 */
public class SingleDog {
    private static SingleDog sd = null;

    private SingleDog() {}
	
    // 同步方法
    public static synchronized SingleDog getInstance() {
        if (null == sd) {
            sd = new SingleDog();
        }

        return sd;
    }
}

public class SingleDog1 {
    private static SingleDog1 sd = null;

    private SingleDog1() {}

    // 同步代码块
    public static  SingleDog1 getInstance() {
        synchronized (SingleDog1.class) {
        	if (null == sd) {
        	    sd = new SingleDog1();
        	}
    	}
    
        return sd;
    }
}

1.3 另一种单例模式【饿汉】

package com.qfedu.a_single;

/**
 * 另一个单例模式
 *
 * @author Anonymous 2020/3/13 11:44
 */
public class SingleCat {
    /*
    static修饰，在代码的加载阶段创建完成
    并且使用final修饰，保存当前指向不可以改变
    private修饰类外无法直接获取，不能修改
     */
    private static final SingleCat sc = new SingleCat();

    private SingleCat() {}

    /*
    使用方法做的统一
     */
    public static SingleCat getInstance() {
        return sc;
    }
}