设计模式-创建型模式-单例模式-懒汉式

本文主要是介绍设计模式-创建型模式-单例模式-懒汉式，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

设计模式-创建型模式-单例模式-懒汉式

- 一、创建型模式
- 二、单例模式
- 三、懒汉式
- - 1.单线程懒汉式单例
  - - 代码段1:单线程懒汉模式单例
    - 代码段2:单线程测试懒汉模式单例
    - 代码段3:多线程测试懒汉模式单例
  - 2.多线程懒汉式单例
  - - 代码段4:懒汉模式单例加锁(多线程)
  - 3.完整版懒汉模式单例

一、创建型模式

创造型模式主要的关注点是怎么创建对象,主要特点是将对象的创建和使用分离开来。以此降低系统的耦合度，使用者可以不需要过分关注对象的创建细节，直接使用就可以。

创造模式例子：

去商城购买商品，并不需要知道商品是怎么来的怎么生产的，只需要买来使用就可以；
去饭店吃饭，不需要考虑才是怎么做出来的，直接点了吃就完事；

二、单例模式

单例模式是创建型模式的其中一个模式，一般只一个类只有一个实例（只实例化一次），并且这个这个实例化的过程是在这个类本身完成的，只是对外开放了一个获取这个实例了的对象的方法。

单例模式例子：

win系统内的回收站就是全局唯一的，不论在哪里删除或者创建图标，整个系统内只有一个回收站实例，创建的多个图标也都是指向了这个实例；

三、懒汉式

懒汉式单例是指类在用的时候才会实例化,并且只有在第一次被调用时会实例化一次,多次调用都是返回第一次实例化的对象。

1.单线程懒汉式单例

一下是简单地一个样例,该例子可以在单线程模式下保持全局单例:

代码段1:单线程懒汉模式单例

//代码段1:单线程懒汉模式单例
package com.lqh.singleton;

/**
 * 单例模式-懒汉式
 * @author lqh
 * @version 1.0
 * @date: 2021/7/9 21:23
 */
public class LazySingleton {
    /**
     * 在类内私有化一个静态对象,也就是唯一的实例,外面获取的实例都是指向这个对象
     */
    private static LazySingleton instance;

    /**
     * 构造方法私有化,防止在其他地方被实例化
     * 此处虽然私有化了构造方法,但是还是能被反射获取到并调用
     */
    private LazySingleton(){}

    /**
     * 返回本类的实例对象,如果对象为空代表还没有被实例化,
     * 就需要调用构造方法实例化后返回
     * @return
     */
    public static LazySingleton getInstance(){
        if (instance == null){
            instance = new LazySingleton();
        }
        return instance;
    }

}

然后运行测试一下

代码段2:单线程测试懒汉模式单例

//代码段2:单线程测试懒汉模式单例
package com.lqh;

import com.lqh.singleton.LazySingleton;

import java.util.ArrayList;
import java.util.List;

/**
 * 主类
 * @date 22:24 2021/7/9
 * @author lqh
 */
public class Main {

    /**
     * 比较两个对象是否相同
     * @param i1
     * @param i2
     */
    private static void equals(LazySingleton i1, LazySingleton i2){
        if (!i1.equals(i2)){
            System.out.println("有不同的实例!");
        }
    }

    public static void main(String[] args) {
        //获取对象
        LazySingleton instance1 = LazySingleton.getInstance();
        //打印哈希码值
        System.out.println(instance1.toString());//com.lqh.singleton.LazySingleton@1b6d3586

        LazySingleton instance2 = LazySingleton.getInstance();
        //打印哈希码值
        System.out.println(instance2.toString());//com.lqh.singleton.LazySingleton@1b6d3586

        //比较两个对象是否相同
        System.out.println(instance1.equals(instance2));//true

        //获取十次并加入列表
        List<LazySingleton> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            //获取实例
            LazySingleton instance = LazySingleton.getInstance();
            //将获取的实例加入列表
            list.add(instance);
        }

        //遍历列表打印每个实例的哈希码值
        list.forEach(x -> System.out.println(x));//无一例额外全部都是com.lqh.singleton.LazySingleton@1b6d3586

        //遍历列表将每个实例都与列表内的所有实例比对一遍,有不同的就输出不同
        list.forEach(x -> {
            for (LazySingleton instance : list) {
                equals(x, instance);//全部相同
            }
        });

    }
}

运行结果:

com.lqh.singleton.LazySingleton@1b6d3586
com.lqh.singleton.LazySingleton@1b6d3586
true
com.lqh.singleton.LazySingleton@1b6d3586
com.lqh.singleton.LazySingleton@1b6d3586
com.lqh.singleton.LazySingleton@1b6d3586
...

上面可以看到在main线程下生成的所有LazySingleton对象都指向了同一个哈希码值的对象,毕竟他们都是调用的同一个方法(getInstance)：

//代码段1片段
public static LazySingleton getInstance(){
        if (instance == null){
            instance = new LazySingleton();
        }
        return instance;
    }

并且返回的也都是instance这个对象:

//代码段1片段
private static LazySingleton instance;

但是如果在多线程模式下这个方法就不在适用，因为多线程模式下可以看做是两个或多个线程同时在执行,比如两个线程A和B,线程A在调用getInstance()方法的时候检测到instance对象为空实例化了一个对象,线程B在A正在实例化对象的时候也调用了getInstance()方法,此时A线程还没有实例化完成,导致B线程也检测到instance对象时空,也会进行实例化,这就导致了两个对象的生成,打破了单例模式。

多线程测试：

代码段3:多线程测试懒汉模式单例

//代码段3:多线程测试懒汉模式单例
package com.lqh;

import com.lqh.singleton.LazySingleton;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * 主类
 * @date 22:24 2021/7/9
 * @author lqh
 */
public class Main {

    /**
     * 比较两个对象是否相同
     * @param i1
     * @param i2
     */
    private static void equals(LazySingleton i1, LazySingleton i2){
        if (!i1.equals(i2)){
            System.out.println("有不同的实例!");
        }
    }

    public static void main(String[] args) {
        //创建一个线程安全的列表,用来保存实例对象
        List<LazySingleton> list = Collections.synchronizedList(new ArrayList<>());

        //创建十个线程,且每个线程获取LazySingleton实例
        for (int i = 0; i < 10; i++) {
            new Thread(() ->{
                LazySingleton instance = LazySingleton.getInstance();
                list.add(instance);
            }, "线程" + (i+1)).start();
        }

        //遍历列表打印每个实例的哈希码值
        list.forEach(x -> System.out.println(x));

        //遍历列表比较每一个实例是否相同
        list.forEach(x -> {
            for (LazySingleton instance : list) {
                equals(x,instance);
            }
        });

    }
}

运行结果:

com.lqh.singleton.LazySingleton@3d075dc0
com.lqh.singleton.LazySingleton@214c265e
com.lqh.singleton.LazySingleton@448139f0
com.lqh.singleton.LazySingleton@7cca494b
com.lqh.singleton.LazySingleton@7cca494b
com.lqh.singleton.LazySingleton@448139f0
com.lqh.singleton.LazySingleton@448139f0
com.lqh.singleton.LazySingleton@448139f0
com.lqh.singleton.LazySingleton@448139f0
com.lqh.singleton.LazySingleton@448139f0
有不同的实例!
有不同的实例!
有不同的实例!
有不同的实例!
有不同的实例!
...

可以看到在多线程模式下就产生了多个不同的对象，为了避免这个情况就需要用到锁了,改进一下代码,只改动了getInstance()方法:

2.多线程懒汉式单例

代码段4:懒汉模式单例加锁(多线程)

//代码段4:懒汉模式单例加锁
package com.lqh.singleton;

/**
 * 单例模式-懒汉式
 * @author lqh
 * @version 1.0
 * @date: 2021/7/9 21:23
 */
public class LazySingleton {
    /**
     * 在类内私有化一个静态对象,也就是唯一的实例,外面获取的实例都是指向这个对象
     */
    private static LazySingleton instance;

    /**
     * 构造方法私有化,防止在其他地方被实例化
     * 此处虽然私有化了构造方法,但是还是能被反射获取到并调用
     */
    private LazySingleton(){}

    /**
     * 返回本类的实例对象,如果对象为空代表还没有被实例化,
     * 就需要调用构造方法实例化后返回
     * @return
     */
    public static LazySingleton getInstance(){
        //在检测时加一层锁,锁住本类
        synchronized(LazySingleton.class){
            if (instance == null){
                instance = new LazySingleton();
            }
            return instance;
        }
    }

}

再次运行单线程(代码段2)和多线程(代码段3)的代码:

单线程:

com.lqh.singleton.LazySingleton@1b6d3586
com.lqh.singleton.LazySingleton@1b6d3586
true
com.lqh.singleton.LazySingleton@1b6d3586
com.lqh.singleton.LazySingleton@1b6d3586
...

多线程:

com.lqh.singleton.LazySingleton@3d075dc0
com.lqh.singleton.LazySingleton@3d075dc0
com.lqh.singleton.LazySingleton@3d075dc0
...

可以看到在加了一次锁之后在多线程模式下就又成功回到单例模式

3.完整版懒汉模式单例

由于以下内容暂时还无法理解所以先只是贴出有待再研究

package com.lqh.singleton;

/**
 * 单例模式-懒汉式
 * @author lqh
 * @version 1.0
 * @date: 2021/7/9 21:23
 */
public class LazySingleton {

    /**
     * 在类内私有化一个静态对象,也就是唯一的实例,外面获取的实例都是指向这个对象
     * 新增volatile关键字防止指令重排(?何为指令重排)
     */
    private static volatile LazySingleton instance;

    /**
     * 构造方法私有化,防止在其他地方被实例化
     * 此处虽然私有化了构造方法,但是还是能被反射获取到并调用
     */
    private LazySingleton(){}

    /**
     * 返回本类的实例对象,如果对象为空代表还没有被实例化,
     * 就需要调用构造方法实例化后返回
     * @return
     */
    public static LazySingleton getInstance() {
        //第一层检查是否实例化对象
        if (instance == null) {
            //加锁避免线程不安全
            synchronized (LazySingleton.class) {
                //再次检查是否有实例化,没有就实例化(?为何二次检查)
                if (instance == null) {
                    instance = new LazySingleton();
                }
            }
        }
        //返回
        return instance;
    }

}

运行单线程(代码片段2)和多线程(代码片段3)的测试结果和多线程懒汉式单例的结果一样就不再次贴出

这篇关于设计模式-创建型模式-单例模式-懒汉式的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

Java教程