博客

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

注意：

• 单例类只能有一个实例。
• 单例类必须自己创建自己的唯一实例。
• 单例类必须给所有其他对象提供这一实例。

单例模式需保证构造器私有化，以防止构

new

此对象。

饿汉式

饿汉式 某些时候浪费空间较多。

/**
 * 饿汉式
 */
public class hungry {
    //让构造函数为 private，这样该类就不会被实例化
    public hungry() {}

    //创建 hungry 的一个对象
    private final static hungry H = new hungry();

    //获取唯一可用的对象
    public static hungry getHungry(){
        return H;
    }

}

懒汉式

/**
 * 懒汉式
 */
public class LazyMan {
    //让构造函数为 private，这样该类就不会被实例化
    public LazyMan() {}

    //volatile 防止可能发生指令重排现象
    private volatile static LazyMan H;

    //获取唯一可用的对象
    public static LazyMan getHungry(){
        //第一次判断，假设会有好多线程，如果LazyMan没有被实例化，那么就会到下一步获取锁，只有一个能获取到，
        //如果已经实例化，那么直接返回了，减少除了初始化时之外的所有锁获取等待过程
        if(null == H){
            synchronized (LazyMan.class){
                //第二次判断是因为假设有两个线程A、B,两个同时通过了第一个if，然后A获取了锁，进入然后判断LazyMan是null，
                // 他就实例化了LazyMan，然后他出了锁，这时候线程B经过等待A释放的锁，B获取锁了，
                // 如果没有第二个判断，那么他还是会去new LazyMan()，再创建一个实例，所以为了防止这种情况，需要第二次判断
                if(null == H){
                    //下面这句代码其实分为三步：
                    //1.开辟内存分配给这个对象
                    //2.初始化对象
                    //3.将内存地址赋给虚拟机栈内存中的LazyMan变量
                    //注意上面这三步，第2步和第3步的顺序是随机的，这是计算机指令重排序的问题
                    //假设有两个线程，其中一个线程执行下面这行代码，如果第三步先执行了，就会把没有初始化的内存赋值给LazyMan
                    //然后恰好这时候有另一个线程执行了第一个判断if(null == LazyMan)，然后就会发现LazyMan指向了一个内存地址
                    //这另一个线程就直接返回了这个没有初始化的内存，所以要防止第2步和第3步重排序
                    H = new LazyMan();
                }
            }
        }
        return H;
    }
}