设计模式之单例模式

单例模式

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

---

饿汉式

//饿汉式，使用static机制在类初始化时便产生一个对象
//但是这种机制会浪费内存，不太提倡使用这种用法
public class Hunger01 {
    //构造器私有化，防止外部创建实例
    private Hunger01(){};

    //内部创建实例方法
    private final static Hunger01 instance =new Hunger01();

    //
    public static Hunger01 getInstance(){
        return instance;
    }
}

懒汉式-单线程版

//单线程顾名思义，此方法只能在单线程下起作用
//对于多线程仍然会得到instance为null的情况，因此正常情况下不会使用这种方法
//可以使用synchronized锁getInstance方法，但是效率低容易阻塞，也不推荐这种用法，故省略
public class Lazy01 {

    //构造器私有化，防止外部创建实例
    private Lazy01(){};
    //声明静态成员属性
    private static Lazy01 instance;

    public static Lazy01 getInstance(){
        if (null==instance){
            instance=new Lazy01();
        }
        return instance;
    }
}

懒汉式-双检查版-多线程环境下线程安全

public class Lazy03 {

    //构造器私有化
    private Lazy03() {}
    
    //注意volatile
    private static volatile Lazy03 instance;

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

懒汉式-静态内部类机制-多线程下线程安全

public class Lazy04 {

    private Lazy04(){};

    //Lazy是静态内部类，当外部类Lazy04加载时，静态内部类不会被加载
    //当调用Lazy.instance时才会被装载，在装载类时，根据类加载机制，此时是线程安全的
    private static class Lazy{
        private static final Lazy04 instance=new Lazy04();
    }

    public static Lazy04 getInstance(){
        return Lazy.instance;
    }

    public static void main(String[] args) {
        if (Lazy04.getInstance()==Lazy04.getInstance()){
            System.out.println("bingo");
        }
    }
}