java设计模式----单例设计模式

1. 看待设计模式，要站在更大的角度（代码重用性、可读性、可扩展性、可靠性、程序高内聚，低耦合）来综合考虑看待，而不是功能实现的角度看待，不要觉得实现一个功能没必要这么麻烦

2. 文章中给出的设计模式类图都是标准的实现方式，并不一定要完全遵守标准，所以只要设计思想符合，一个设计模式有多种实现方式，尤其是看别人源码的时候，不要用标准类图死扣

1. 单例设计模式

1. 采取一定方法，保证整个软件系统运行中，只存在一个对象实例，且该类只提供一个取得其对象实例的方法
2. 例如Hibernate的SessionFactory，它充当数据存储源的代理，负责创建Session对象，它不是轻量级的，一般情况下，一个项目通常只需要一个SessionFactory就够了，这时就需要单例模式

1. 饿汉式单例模式，如果你保证项目中必然会用到这个实例，就可以用，否则会资源浪费
2. 懒汉式—双重检查版，如果项目中不一定用到这个实例，为了避免资源浪费，可以用懒汉式，但是多线程高并发场景下，需要双重检查保证线程安全
3. 静态内部类实现单例，根据JVM底层运行原理实现
4. 枚举类实现单例，好用，推荐

1. 饿汉式单例

1. 类被加载，就实例化了实例，一直等着被使用，所以叫饿汉式

1. 写法简单，类加载时就完成实例化，避免线程同步问题

1. 类加载时就完成实例化，没有达到懒加载（Lazy Loading）效果，如果从始至终从未使用过这个实例，则会造成内存浪费
2. 基于classloder（类加载）机制，避免了多线程同步问题，但是，instance（实例）在类加载时就实例化。在单例模式中，大多调用getInstance方法，触发类加载，但是如果有其它静态方法等一系列东西导致类加载，此时虽然我们不想使用这个单例，内存中也初始化了它。
3. 这种单例模式可用，但是可能造成内存浪费

1. 静态常量版本

1. 构造器私有化(保证外部不可以new对象)
2. 类的内部创建自己的实例对象（外部不能new，那就自己new）
3. 向外暴露一个静态公共方法(外部只能通过这个方法，获取我们自己new的那一个对象)

/**
 * 饿汉式单例设计模式------静态常量版
 */
public class StaticConstSingleton {
    public static void main(String[] args) {
        //获取到单例实例，一个类，整个项目运行时，只有一个类对象，所以获取到的实例都会是同一个
        StaticConstSingleton singleton = StaticConstSingleton.getSingleton();
        StaticConstSingleton singleton2 = StaticConstSingleton.getSingleton();
        System.out.println("两个实例是否相同"+(singleton2 == singleton));//结果为true.两个实例对象是同一个
        System.out.println("两个实例hashCode值分别是多少："+singleton2.hashCode()+"==========="+singleton.hashCode());
    }

    //1、私有化构造方法
    private StaticConstSingleton(){

    }
    //2. 自己将实例new出来
    private static final StaticConstSingleton singleton = new StaticConstSingleton();

    //3. 提供公共方法，获取我们自己new出来的实例
    public static StaticConstSingleton getSingleton(){
        return singleton;
    }
}

2. 静态代码块版本

1. 构造器私有化(保证外部不可以new对象)
2. 类的内部创建自己的实例对象（外部不能new，那就自己new）
3. 向外暴露一个静态公共方法(外部只能通过这个方法，获取我们自己new的那一个对象)

/**
 * 饿汉式单例设计模式------静态代码块版
 */
public class StaticCodeBlock {
    public static void main(String[] args) {
        //获取到单例实例，一个类，整个项目运行时，只有一个类对象，所以获取到的实例都会是同一个
        StaticCodeBlock singleton = StaticCodeBlock.getInstance();
        StaticCodeBlock singleton2 = StaticCodeBlock.getInstance();
        System.out.println("两个实例是否相同"+(singleton2 == singleton));//结果为true.两个实例对象是同一个
        System.out.println("两个实例hashCode值分别是多少："+singleton2.hashCode()+"==========="+singleton.hashCode());
    }
    //1.私有化构造
    private StaticCodeBlock(){}
    //2.自己定义单例
    private static StaticCodeBlock staticCodeBlock ;
    //3.静态代码块搞出来实例
    static{
        staticCodeBlock = new StaticCodeBlock();
    }
    //4.提供方法
    public static StaticCodeBlock getInstance(){
        return staticCodeBlock;
    }
}

2. 懒汉式

1. 懒加载机制，不浪费内存，调用getInstance方法才会new实例
2. 但是多线程下需要解决线程安全和同步问题

1. 线程不安全

1. 私有化构造函数
2. 自己创静态实例，但不初始化
3. 提供公共静态方法获取实例，并在这里初始化单例

1. 当第一个线程进入getInstace中，判断singleton为null，则创建单例
2. 此时单例初始化未完成，又一个线程进入，发现singleton没有值，又进行一次初始化。出现多次初始化的问题。
3. 又一个线程进入，发现有值，不为null，所以直接拿走实例
4. 此时，这个线程拿了一个没有初始化完成的实例对象走了，程序出错

/**
 * 懒汉式单例
 * 线程不安全版
 */
public class ThredUnsafetySingleton {
    public static void main(String[] args) {
        ThredUnsafetySingleton singleton = ThredUnsafetySingleton.getInstance();
        ThredUnsafetySingleton singleton2 = ThredUnsafetySingleton.getInstance();
        System.out.println("两个实例是否相同"+(singleton2 == singleton));
    }
    //1. 私有化构造函数
    private ThredUnsafetySingleton(){}
    //2. 自己创静态实例，但不初始化
    private static ThredUnsafetySingleton singleton;
    //3. 提供公共静态方法获取实例，并在这里初始化单例
    public static ThredUnsafetySingleton getInstance(){
        if(singleton == null){
            singleton = new ThredUnsafetySingleton();
        }
        return singleton;
    }
}

2. 线程安全，同步方法

1. 在线程不安全的懒汉式版本基础上，为getInstance方法添加synchronize关键字

1. 虽然解决了线程不安全问题
2. 但是效率太低，每个线程想要获取类实例时，执行getInstance()方法都要进行同步，但是实例化代码只需要执行一次就够了，后面想获得该实例，直接return即可，但是现在连return都需要同步

/**
 * 懒汉式单例
 * 线程安全版，对方法进行同步
 */
public class ThreadSafetySingleton {
    public static void main(String[] args) {
        ThredUnsafetySingleton singleton = ThredUnsafetySingleton.getInstance();
        ThredUnsafetySingleton singleton2 = ThredUnsafetySingleton.getInstance();
        System.out.println("两个实例是否相同"+(singleton2 == singleton));
    }
    //1. 私有化构造方法
    private ThreadSafetySingleton(){}
    //2. 创建static实例
    private static ThreadSafetySingleton singleton;
    //3. 提供公共静态方法获取实例，并在这里初始化单例，并加入synchronize关键字修饰代码块
    public static synchronized ThreadSafetySingleton getInstance(){
        if(singleton == null){
            singleton = new ThreadSafetySingleton();
        }
        return singleton;
    }
}

3. 线程安全，同步代码块

1. 在线程不安全的懒汉式版本基础上，为getInstance方法中实例化单例的代码添加synchronize关键字

1. 虽然解决了效率问题，线程直接return对象时，不需要实例化单例。但是线程不安全问题重新出现了
2. 当一个线程进行初始化，此时其它线程判断null进来发现代码加锁，等第一个线程走了，他还是会去执行初始化代码
3. 依然会有线程拿一个默认值走的情况发生

/**
 * 懒汉式单例
 * 线程安全版，对代码块进行同步
 */
public class ThreadSafetySynchroniztionCodeBlockSingleton {
    //1. 私有化构造
    private ThreadSafetySynchroniztionCodeBlockSingleton(){}
    //2. 创建静态实例
    private static ThreadSafetySynchroniztionCodeBlockSingleton singleton;
    //3. 提供公共方法获取单例,只对实例化单例时的操作加锁做同步
    public static ThreadSafetySynchroniztionCodeBlockSingleton getInstance(){
        if(singleton == null){
            synchronized (ThreadSafetySynchroniztionCodeBlockSingleton.class){
                singleton = new ThreadSafetySynchroniztionCodeBlockSingleton();
            }
        }
        return singleton;
    }
}

4. 双重检查(重点)

1. 在线程安全，同步代码块的基础上，synchronized代码块中，也加上判断

1. 解决线程安全问题
2. 效率比直接同步方法高,只有初始化时需要同步，获取实例时，不需要同步
3. 当多个线程判断实例为null，进入if执行初始化，因为初始化代码加锁，只有一个能进去
4. 此时，加锁代码中，再次判断是否为null，如果是null执行初始化。第一个线程进去会执行初始化，初始化完成，释放锁，第二个线程进去再次判断，发现不为null，不执行初始化

/**
 * 懒汉式单例
 * 线程安全，双重检查
 */
public class DoubleCheck {
    //1. 私有化构造
    private DoubleCheck(){}
    //2. 创建静态实例
    private static DoubleCheck singleton;
    //3. 提供公共方法获取单例,只对实例化单例时的操作加锁做同步
    public static DoubleCheck getInstance(){
        if(singleton == null){
            //假设多个线程同时判断null进来初始化，此时这里只能进入一个线程初始化
            synchronized (DoubleCheck.class){
                if(singleton == null){//双重检查，第一个线程初始化完成，其它线程再进来，singleton就不是null了，不会重复初始化
                    singleton = new DoubleCheck();
                }
            }
        }
        return singleton;
    }
}

3. 静态内部类

1. 外部类被加载时，静态内部类不会被装载
2. 当我们使用静态内部类中静态变量或常量时，会加载内部类
3. 类加载时，是线程安全的（JVM帮我们保证线程安全，类初始化时，其它线程无法进入）

1. 私有构造
2. 静态内部类，创建实例
3. 提供公共方法获取单例对象(使用静态内部类变量)

/**
 * 静态内部类创建单例
 * 线程安全，效率高
 * 代码简洁
 * > 1. 外部类被加载时，静态内部类不会被装载
 * > 2. 当我们使用静态内部类中静态变量或常量时，会加载内部类
 * > 3. 类加载时，是线程安全的
 */
public class InnerClassSingleton {
    //1. 私有构造
    private InnerClassSingleton(){}
    //2. 静态内部类，创建实例
    private static class SingletonInstance{
        private static final InnerClassSingleton INSTANCE = new InnerClassSingleton();
    }
    //3. 提供公共方法获取单例对象
    public static InnerClassSingleton getInstance(){
        return SingletonInstance.INSTANCE;//使用静态内部类变量时，会加载内部类
    }
}

4. 枚举

1. 借助JDK1.5中加入的枚举来实现单例模式，不仅可以避免多线程同步问题，还能防止反序列化重新创建新对象
2. 是Effective Java作者Josh Bloch提倡的方式

1. 创建枚举
2. 声明属性
3. 用就完事了

/**
 * 使用枚举，实现单例
 */
public class EmnuSingleton {
    public static void main(String[] args) {
        Singleton instance = Singleton.INSTANCE;
        instance.say();
    }
}
enum Singleton{
    INSTANCE;//属性
    public void say(){
        System.out.println("SAY---");
    }
}

2、java源码中哪里用到单例？

1. 我们发现只能通过getRuntime()方法获取Runtime实例对象
   
2. 点进去看逻辑，发现就是简单的懒汉式静态常量版本