【设计模式】 单例模式

package 单例模式;

public class Main {
    public static void main(String[] args) {
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        System.out.println(s1 == s2);//true

        Singleton03 s5 = Singleton03.getInstance();
        Singleton03 s6 = Singleton03.getInstance();
        System.out.println(s5 == s6);//true
    }
}

//todo 饿汉式单例模式
// 写法1 静态常量方式   √

//特点：在类加载的时候就完成了实例化，避免了线程同步问题； 【 类加载时机实际复习 】
//优点：调用的时候速度快
//缺点：占用内存;类加载的时机是不明确的，虽然调用getInstance()是会发生类加载，
//但是无法保证其他方式导致的类加载，这个时候初始化instance就没有达到lazy loading的效果
//从而造成内存浪费

//结论：此种写法可用，但是可能会造成内存浪费
class Singleton{
    //1.构造器私有化
    private Singleton(){}

    //2.本类内部创建对象实例
    //static final变量在类加载的准备阶段完成实例化
    private final static Singleton instance = new Singleton();

    //3.提供一个静态共有方法，返回实例对象
    public static Singleton getInstance(){
        return instance;
    }
}

//todo 饿汉式单例模式
// 写法2: 在静态代码块中实例化   √
class Singleton02{
    //1.构造器私有化
    private Singleton02(){}

    //2.本类内部创建对象实例
    //static final变量在类加载的准备阶段完成实例化
    private final static Singleton02 instance;

    static{
        instance = new Singleton02();
    }

    //3.提供一个静态共有方法，返回实例对象
    public static Singleton02 getInstance(){
        return instance;
    }
}


//todo 3.懒汉式
// 线程不安全写法   ×

// 优点：lazy loading 用的时候才创建实例
// 缺点：多线程不安全；线程A进入了 if(instance == null)后，cpu被线程B抢去了，此时线程A并未初始化instance,因此仍然为null
//  当B通过了if判断，并且执行了初始化，然后线程A回来继续执行，此时就会产生多个实例
class Singleton03{
    //1.构造器私有化
    private Singleton03(){}

    //2.本类内部创建对象实例
    //静态的final变量只能在声明时或者静态代码块中进行初始化，所以这里去掉final
    private static Singleton03 instance;

    //3.提供一个静态共有方法，返回实例对象
    public static Singleton03 getInstance(){
         if(instance == null){
             instance = new Singleton03();
         }
         return instance;
    }
}
//todo 4.懒汉式
// 线程安全写法 - synchronized   同步方法    ×

// 缺点：效率低   每个线程想要获取类实例的时候，都要执行getInstance()
//              由于这个方法同步，因此线程只能等待；其实这个方法只需要执行一次创建了实例即可，后面的线程想要获取该实例直接return就行了
class Singleton04{
    //1.构造器私有化
    private Singleton04(){}

    //2.本类内部创建对象实例
    //静态的final变量只能在声明时或者静态代码块中进行初始化，所以这里去掉final
    private static Singleton04 instance;

    //3.提供一个静态共有方法，返回实例对象
    public static synchronized Singleton04 getInstance(){
        if(instance == null){
            instance = new Singleton04();
        }
        return instance;
    }
}
//todo 5 懒汉式  解决线程安全问题的错误写法    ×
//错误的原因和第四个是一样的，都是判断为null之后进入了if的代码块，此时只是排队实例化
class Singleton05{

    private Singleton05(){}

    private static Singleton05 instance;

    //3.提供一个静态共有方法，返回实例对象
    public static Singleton05 getInstance(){
        if(instance == null){
            synchronized (Singleton05.class){
              instance = new Singleton05();
            }
        }
        return instance;
    }
}


//todo 6.懒汉式
// 线程安全写法 - 双重判null    推荐使用

// 第一个instance==null 假设有A B 两个线程进入了
// 第二个instance==null 只能有一个线程进入，假设A进入了
// 因此只有第一个获取锁的线程 A 能够进行初始化，后面的线程 B 获取锁的时机 是被线程 A 实例化之后的，因此保证了线程安全
// 并且往后的线程C D 在第一个instance==null 就判断完成了，不用在获取锁了，因此提高了效率

// 优点：效率高、线程安全、懒加载
class Singleton06{

    private Singleton06(){}

    //volatile  线程间内存共享
    private static volatile Singleton06 instance;


    public static Singleton06 getInstance(){
        if(instance == null){
            synchronized (Singleton06.class){
                if(instance == null){
                    instance = new Singleton06();
                }
            }
        }
        return instance;
    }
}

//todo 7.静态内部类实现单例模式
//1.静态内部类不会随着外部类的加载而被加载   保证了懒加载
//2.类的初始化知识：当我们调用getInstance()的时候，会访问静态内部类的静态类变量，会导致静态内部类的加载
//3.类加载的知识：static final变量是在类加载中的连接阶段进行初始化的
//4.类加载的知识：类加载阶段执行的clinit()方法是上锁了的，因此是线程安全的！

//推荐使用

class Singleton07{

    private Singleton07(){}

    private static class SingletonInstance{
        private static final Singleton07 INSTANCE = new Singleton07();
    }

    public static Singleton07 getInstance(){
        return SingletonInstance.INSTANCE;
    }

}

//todo 8.枚举
//优点：线程安全，防止反序列化重新创建新的对象   Effective Java作者提倡的方式
enum Singleton08{
    INSTANCE;
    public void sayOK(){
        System.out.println("ok~");
    }
}

//todo 单例模式注意事项
//1.单例模式保证了系统内存只有该类的一个对象，对于需要频繁创建销毁的对象，使用
//单例模式可以提高系统性能

//2.获取单例类对象的时候，必须使用相应的获取对象的方法，而不是new

//3.单例模式使用场景：频繁创建和销毁的对象、工具类对象、重的对象