栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

五种单例模式

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

五种单例模式

文章目录
    • 饿汉式(不推荐)
    • 懒汉式(不推荐)
    • 双重锁检测模式(Double Check Lock)(推荐)
    • 静态内部类模式(推荐)
    • 通过枚举实现单例

饿汉式(不推荐)

顾名思义,有饥饿感,提前就加载了,饿汉式在类被加载的时候就创建好了实例,此时有可能实例还没有用到。两种写法:

public class Singleton {
    private static Singleton instance = new Singleton();  // 直接初始化一个实例对象

    // private类型的构造函数,确保其它类对象不能new一个本类的实例
    private Singleton() {
    }

    public static Singleton getInstance() {
        return instance;
    }
}
public class Singleton {
    private static Singleton instance;
    
    static {
        instance = new Singleton();
    }

    // private类型的构造函数,确保其它类对象不能new一个本类的实
    private Singleton() {
    }

    public static Singleton getInstance() {
        return instance;
    }
}
懒汉式(不推荐)
public class Singleton {
    private static Singleton instance;

    private Singleton() {
    }

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

懒汉式只有在实际需要的时候才会创建实例,实现起来也很简单,由一个静态方法返回实例,同时对这个静态方法加了一把锁,所有来获取实例的方法都会去竞争这把锁,不管实例有没有创建。不加锁线程不安全。

但这也带来了一个问题,就是锁的粒度太粗。实际上,只有首次创建实例时,为了防止多线程同时创建多个实例才需要锁,当实例已经创建完成后,直接返回实例就好,不再需要什么锁了。但在当前示例里,不管实例有没有创建,只要想获取实例,就要去竞争锁,显然是扩大了锁的竞争范围,效率肯定会降低。所以引入双重锁检查模式

双重锁检测模式(Double Check Lock)(推荐)
public class Singleton {
    private static volatile Singleton instance;

    private Singleton() {
    }

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

        return instance;
    }
}

DCL模式也是在使用时才会创建,且只在首次创建实例时有锁竞争,实例创建完成后,每次获取实例时,在第一次检测时就已经知道实例创建好了,不会再执行synchronized里的代码段,也就没有锁竞争了,效率明显比懒汉式提高了不少。

解释下为什么获取到锁之后还要再次检测:因为第一次检测时没有加锁,那么获取到锁之后,有可能别的线程已经创建好了,如果不判断直接创建,就可能实际上创建了多个实例,达不到单例的目的了。

同时,请注意,这里还用到了volatile关键字来修饰instance,其最关键的作用是防止指令重排序,具体分析过程如下:
当在Java中new一个对象时,如instance = new Singleton();,其实在JVM里面的步骤分为三步:

  1. 在堆内存开辟内存空间
  2. 在堆内存中使用参数对Singleton进行实例化
  3. 把变量instance指向堆内空间地址

由于JVM存在乱序执行功能,有可能第3步骤先于第2步执行。假如线程A执行完第3步后,线程B来获取实例,此时instance已经不为null了,线程B获取到了实例,但此时线程A第2步还没执行,实例还没完成初始化,线程B获取到的是不完整的实例,那么在使用时就会出问题。
volatile的可以禁止指令重排序,从而避免了上述问题的出现。

静态内部类模式(推荐)
public class Singleton {
    private Singleton() {
    }

    private static class Inner {
        private static Singleton instance = new Singleton();
    }

    public static Singleton getInstance() {
        return Inner.instance;
    }
}

静态内部类模式的实现原理:外部类加载时,并不会立刻加载内部类,内部类不被加载,就不会去创建实例,只有当getInstance方法被调用时,才会加载内部类去创建实例,所以实现了延迟加载功能。

那么内部静态类是如何保证线程安全的呢?在《深入理解JAVA虚拟机》中,有这么一句话:

虚拟机会保证一个类的()方法在多线程环境中被正确的加锁、同步,如果多个线程同时去初始化一个类,那么只会有一个线程去执行这个类的()方法,其它线程都需要阻塞等待,直到活动线程执行()方法完毕。如果一个类的()方法有耗时很长的操作,就可能造成多个线程阻塞(需要注意的是,其它线程虽然会被阻塞,但如果执行()方法后,其它线程被唤醒之后不会再次进入()方法。同一个加载器下,一个类型只会被初始化一次),在实际应用中,这种阻塞可能是很隐蔽的。

通过枚举实现单例

最佳的单例实现模式就是枚举模式。利用枚举的特性,让JVM来帮我们保证线程安全和单一实例的问题。除此之外,写法还特别简单。

public enum Singleton {
    INSTANCE;

    public void doSomething() {
        System.out.println("do something!");
    }
}

调用方法:

public class Main {
    public static void main(String[] args) {
        Singleton.INSTANCE.doSomething();
    }
}
转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/951019.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号