Java实现设计模式之——单例模式

奋斗吧

擅长邻域：未填写

标签： Java实现设计模式之——单例模式 JavaScript博客 51CTO博客

2023-03-25 18:45:43 131浏览

Java实现设计模式之——单例模式，Java实现设计模式之——单例模式

1.什么是单例模式？

单例模式是 Java 中最简单也是最常用的设计模式之一，这种模式属于创建者模式。单例模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有一个对象被创建。这个类提供了一种访问其唯一对象的方式，可以直接获取该对象。

2.单例模式的实现

单例模式的实现，我们主要分为两种，一种叫饿汉式另外一种叫懒汉式。

2.1 饿汉式单例模式

饿汉式，顾名思义让人感觉非常急不可耐，所以它会直接在类加载时就将我们的唯一对象实例化好了。用不用该对象它不管，反正它提前帮你实例化好了。具体的细节见代码注释

//饿汉模式
class Singleton {
    //一个 Java 程序中，一个类对象只存在一份
    //1.使用static创建一个实例，并且立即进行初始化
    private static Singleton instance = new Singleton();

    //2.为了防止在其他地方new这个对象，将构造方法写为private
    private Singleton() {
    }

    //3.提供一个方法，让外面能够拿到唯一实例
    public static Singleton getInstance() {
        return instance;
    }
}

为了检验我们得到的对象是否是同一个对象，我们可以调用两次getInstance方法来检验一下获取的两个对象是否是同一个。

public class Main{
    public static void main(String[] args) {
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance1==instance2);  //打印结果为 true
    }  
}

打印结果为true，说明饿汉式的单例模式我们就实现完毕了。

2.2 懒汉式单例模式

懒汉式，顾名思义就是非常懒，它只有在需要调用该对象的时候，如果该对象还未初始化，才会去将其初始化。这就解决了饿汉式的缺点，如果创建了对象却不使用，那不是白白占着内存吗？有句好话说的好，这不是占着茅坑不那啥吗 ?。因此我们可以更改我们的代码实现

//单例模式——懒汉模式
class Singleton2 {
    //1.不会立即进行初始化
    private static Singleton2 instance = null;

    //2.构造方法设为 private
    private Singleton2() {
    }

    //3.提供一个方法获取单例实例
    public static Singleton2 getInstance() {
        if (instance == null) {
            instance = new Singleton2();
        }
        return instance;
      }
}

这样，我们就完成了懒汉式单例模式的实现，它只有在第一次调用getInstance方法时才触发对象实例化，我们同样可以检测一下对象是否一致。

public class Main{
    public static void main(String[] args) {
        Singleton2 s1=Singleton2.getInstance();
        Singleton2 s2=Singleton2.getInstance();
        System.out.println(s1==s2); //返回结果为true
    }
}

3.线程安全的单例模式

很显然，上述代码的是一个线程不安全的单例模式实现。如果两个线程 A，B同时通过 instance==null的判断，那么两个线程都会执行实例化操作，那这样对象就被实例了两次了。

3.1 版本 1

那如何解决线程安全问题呢？显然根据我们学过的线程知识那就是进行加锁。 既然如此，我们每次只允许一个线程来判断即可，于是写出下列代码：

class Singleton {
    //1.不会立即进行初始化
    private static Singleton instance = null;

    //2.构造方法设为 private
    private Singleton() {
    }

    //3.提供一个方法获取单例实例
    public static Singleton getInstance() {
            // 使读写为原子操作，读写合一
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

不过如果你在面试时写出上面的代码，面试官八成是要让你回去等通知了? 。因为仔细观察这个代码，每次在调用getInstance方法时，每个线程都会进行锁竞争导致排队等待，但实际上锁内的实例化代码只会执行一次，这其实就是毫无意义的锁竞争，白白浪费系统资源。

3.2 版本 2 （双重检测）

想要解决上述问题也非常简单，我们只需要在外层再加上一层判断非空判断即可。这样两次判空的机制叫做 双重检测机制。

class Singleton {
    //1.不会立即进行初始化
    private static Singleton instance = null;

    //2.构造方法设为 private
    private Singleton() {
    }

    //3.提供一个方法获取单例实例
    public static Singleton getInstance() {
        // 为了防止大量不必要的锁竞争
        if (instance == null) {   判断1
            // 使读写为原子操作，读写合一
            synchronized (Singleton.class) {
                if (instance == null) {  判断2
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

我们来分析一下为什么这样可以解决版本 1 代码的问题，当多个线程开始并发执行时，肯定会有多个线程同时调用getInstance方法，此时它们他们都能通过判断1。但当进来后，只有持有锁的第一个线程可以通过判断2并完成instance的实例化，然后和它同一批通过判断1的线程轮流持有锁后，都无法通过判断2，也就保证了实例化只进行一次。
最重要的一点来了，当后续有线程再次调用getInstance时，此时instance已经被实例化了，那这些后续来的线程连判断1都无法通过，这也就保证了不会产生无意义的锁竞争。

3.3 版本 3 （禁止指令重排）

虽然版本2的代码已经看上去非常完美了，但仍然存在一个容易让人忽略的问题，那就是 指令重排问题。

那么我们首先要知道——什么是指令重排序？

假设我们要去商场买水果，我们接收到命令需要买的水果有——苹果、西瓜、香蕉、桃子。于是我们按照下图的顺序分别购买，最后离开商场。

Java实现设计模式之——单例模式_java-ee

但很容易发现，上面这个人好像笨笨的，他先去买最远的又倒回来买最近的，但它完全可以按照 苹果-香蕉-西瓜-桃子 这样的顺序购买，消耗的时间更短。这样重新更改执行顺序我们就可以叫做指令重排序。

对于我们给出的指令，jvm也会进行指令重排序，以此选择一些它认为更加优秀的执行方式，但正是如此会带来一些问题。对于一条实例化代码instance = new Singleton();,它实际上的指令会被分为三条：

memory =allocate(); //1：分配对象的内存空间

ctorInstance(memory); //2：初始化对象

instance =memory; //3：设置instance指向刚分配的内存地址

正是因为指令重排序的情况，jvm有可能会更改三条指令的执行顺序，比如出现下面这种情况

memory =allocate(); //1：分配对象的内存空间

instance =memory; //3：设置instance指向刚分配的内存地址

ctorInstance(memory); //2：初始化对象

这会产生什么情况呢？

假设存在线程AB 分别执行到下面两个位置，此时线程 A执行了指令 1,3，还没有执行初始化对象这一步。但线程B在判断时已经发现instacne指向不为null了，于是 返回了一个没有完成初始化的instacne对象。

Java实现设计模式之——单例模式_java_02

那么我们该如何避免上面这种情况呢？也非常简单，只需要在instacne对象前面加上关键字 volatile。它其中一个作用即是禁止指令重排序，那么jvm在操作它时，都会严格按照正常流程执行，这也就解决了上述问题，那么请看最终版代码：

//完善版线程安全单例模式
class Singleton {
    //1.不会立即进行初始化
    private static volatile Singleton instance = null;

    //2.构造方法设为 private
    private Singleton() {
    }

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

好博客就要一起分享哦！分享海报

此处可发布评论

评论（0）展开评论

暂无评论，快来写一下吧

展开评论

您可能感兴趣的博客