设计模式

最新推荐文章于 2021-07-16 21:50:52 发布

Conny?

最新推荐文章于 2021-07-16 21:50:52 发布

阅读量59

点赞数 1

分类专栏：设计模式

本文链接：https://blog.csdn.net/weixin_47246830/article/details/109946077

版权

设计模式专栏收录该内容

1 篇文章 0 订阅

订阅专栏

设计模式之单例模式

要了解单例模式，根据博主本人的学习经历，推荐先去搞懂 java中的 final和static关键字的使用，以及类加载过程。

分享两篇文章(关于 final和static)

https://www.cnblogs.com/shuaiBqi/p/11907908.html

https://blog.csdn.net/qq_41457412/article/details/80598787

1.单例模式

概念：所谓单例模式，就是采取一定的方法保证在整个的软件系统中，对某个类之只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法（静态方法）

单例模式一个类对外只提供一个对象
将构造器私有化
提供静态的属性(本类的对象)
提供共有的静态方法

单例模式的八种方式：

1、饿汉式（静态常量）
2、饿汉式（静态代码块）
3、懒汉式（线程不安全）
4、懒汉式（线程安全，同步方法）
5、懒汉式（线程安全，同步代码块）
6、双重检查
7、静态内部类
8、枚举

1、饿汉式（静态常量）

饿汉式会造成内存的浪费，但是他是安全的没问题的，如果我们可以接受的浪费范围内，或是可以保证这个类会被用到，就是可以使用的

class Singleton{

    //1. 构造器私有化，目的是不能让外面通过 new 的形式 创建Singleton 对象
    private Singleton(){
    }

    //2. 本类内部创建实例
    //final修饰的引用类型变量的地址不能改变，即始终指向一个对象
    //且（被修饰的变量一定要进行初始赋值）详细代码看静态代码块！！！
    private final static Singleton instance = new Singleton();

    //3. 提供一个共有的静态方法 返回该实例对象
    public static Singleton getInstance(){
        return instance;
    }

聊聊优缺点：

1、优点：代码实现简单，在类加载的时候就完成了实例化。避免了线程同步问题。

2、缺点：在类加载的时候就完成了实例化，如果我们一直没用到这个实例，就会造成内存浪费的问题。

结论：这种单例模式是可用的，但是有可能会造成内存浪费。

探讨：1）这种方式基于 classloder 机制避免了多线程的同步问题？？ 2）一般是通过调用上面代码的getInstance()方法对类进行类加载，，有没有其他方法（静态方法）可以让这个类进行加载？？

2、饿汉式（静态代码块）

直接上代码，其他跟静态常量的一样

class Singleton{

    //1. 构造器私有化，目的是不能让外面通过 new 的形式 创建Singleton 对象
    private Singleton(){
    }

    //2. 本类内部创建实例
    //final修饰的引用类型变量的地址不能改变，即始终指向一个对象
    private  static Singleton instance;

    static {
        instance = new Singleton();
    }

    //3. 提供一个共有的静态方法 返回该实例对象
    public static Singleton getInstance(){
        return instance;
    }
    
}

3、懒汉式（线程不安全）

概述：懒汉式，顾名思义就是比较懒，懒汉式不是在程序运行时就加载，而是在有人需要的时候才加载进来；

话不多说直接上代码

class SingleLazy{

    //私有的构造方法
    private SingleLazy(){};

    private static SingleLazy instance;

    //提供共有的静态方法，当使用该方法的时候才去创建对象
    public static SingleLazy getInstance(){

        if (instance==null){
            instance = new SingleLazy();
        }
        return instance;
    }
}

优缺点说明：

1、这种方式只是适用于单线程的情况。reason：在多线程的情况下会有这种情况发生：当一个线程进入到了if (instance==null)这行判断语句的时候，他还未来得及往下执行，另一个线程也进来判断，这时候就会产生多个实例。

2、结论：开发不可使。

4、懒汉式（线程安全，同步方法）

理念和 3 是一样的还是直接上代码

 //私有的构造方法
    private SingleLazy(){};

    private static SingleLazy instance;

    //提供共有的静态方法，当使用该方法的时候才去创建对象
    public synchronized static SingleLazy getInstance(){

        if (instance==null){
            instance = new SingleLazy();
        }
        return instance;
    }

优缺点说明：

1）可以看到我们的 4 相对于 3 就是在静态方法上加了一个 synchronized 锁，他可以解决线程不安全的问题。

2）这种方式效率太低了，在大量的请求都需要这个实例（调用getInstance()方法）时，只有一个请求进来了，其他的还在方法外面排队，效率太低。

3）结论：实际开发中，不推荐使用。

思考：怎么解决这个并发问题呢？？

5、懒汉式（线程安全，同步代码块）

直接上代码

  //提供共有的静态方法，当使用该方法的时候才去创建对象
    public  static SingleLazy getInstance(){

        if (instance==null){
            synchronized (SingleLazy.class){
                instance = new SingleLazy();
            }
        }
        return instance;
    }

直接声明这种方式在开发中是不能使用的：

because：虽然这种写法改为了同步产生实例化的代码块，解决了 4 的效率问题，但是这种同步并不能起到线程同步的作用。在多线程访问的时候也会有多个线程同时进入if (instance==null)判断语句中，这时便产生了多个实例。

6、双重检查（双端检索机制）

推荐使用

先看代码

  //私有的构造方法
    private SingleLazy(){};

    //volatile  作用：让这个共享的变量一旦有被修改能及时的刷新到主内存里面去。
    private static volatile SingleLazy instance;

    //提供共有的静态方法，当使用该方法的时候才去创建对象
    public  static SingleLazy getInstance(){

        if (instance==null){    //判断 1️⃣
            synchronized (SingleLazy.class){
                if (instance==null){ // 判断 2️⃣
                    instance = new SingleLazy();
                }
            }
        }
        return instance;
    }

1、首先这种双重检测的思想在多线程开发中经常被使用到，这不仅可以保证线程的安全性，还能提高性能。

2、原理：当多个请求同时进入判断1️⃣后，只有一个线程会获取到同步代码块（synchronized ）去创建实例，其他等待的线程在获取到锁后去判断f (instancenull) 并直接返回已创建的实例。这样。实例化代码只用执行一次，后面再次访问时，会在if (instancenull)判断1️⃣ 的地方进行判断，，直接返回实例对象，避免反复进行同步的方法中。

3、线程安全；延迟加载；效率较高

4、结论：实际开发中，推荐使用这种单例设计模式。

7、静态内部类

推荐使用

静态内部类的特点：

1）当我们的主类进行类加载的时候我们的静态内部类是不会被加载的。这样保证了懒加载。

2）当我们调用 getInstance方法的时候它才会取这个静态内部类中的静态属性，这时候就会导致 SingletonInstance这个静态内部类被加载，，而我们 jvm 类的加载机制是线程安全的。

代码

public class StaticInnerOne {
    public static void main(String[] args) {
        SingletonStaticInner instance1 = SingletonStaticInner.getInstance();
        SingletonStaticInner instance2 = SingletonStaticInner.getInstance();

        System.out.println(instance1.hashCode());
        System.out.println(instance2.hashCode());
    }
}


class SingletonStaticInner{

    //私有的构造方法,保证类不能被 new
    private SingletonStaticInner(){};

    //写一个静态内部类，该类中有一个静态属性 SingletonStaticInner
    private static class SingletonInstance{
        private static final SingletonStaticInner INSTANCE = new SingletonStaticInner();
    }
    
    // 提供一个静态的方法，再被就调用的时候直接返回 SingletonInstance.INSTANCE 实例
    public static SingletonStaticInner getInstance(){
        return SingletonInstance.INSTANCE;
    }
}

静态内部类的单例模式原理主要是两点：（再次强调）

1）静态内部类方式在SingletonStaticInner类被加载的时候并不会立即实例化，而是在调用 getInstance() 方法的时候才会加载 SingletonInstance 这个类，从而实现懒加载的原理。

2）类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化的时候，别的线程是无法进入的。

3）实际开发中也是推荐使用的。

注：为什么用 final修饰静态变量

***局部内部类在访问他所在方法中的局部变量用final修饰的好处：
因为当调用这个方法时,局部变量如果没有用final修饰,他的生命周期和方法的生命周期是一样的,当方法弹栈,这个局部变量也会消失,那么如果局部内部类对象还没有马上消失想用这个局部变量,就没有了,如果用final修饰会在类加载的时候进入常量池,即使方法弹栈,常量池的常量还在,也可以继续使用

8、枚举

推荐使用

public class EnumOne {
    public static void main(String[] args) {
        SingletonOne instance1 = SingletonOne.INSTANCE;
        SingletonOne instance2 = SingletonOne.INSTANCE;
        System.out.println(instance1 == SingletonOne.INSTANCE);

        System.out.println(instance1.hashCode());
        System.out.println(instance2.hashCode());

        instance1.sayHello();
    }
}

enum SingletonOne {
    INSTANCE; //属性
    public void sayHello(){
        System.out.println("ok~");
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2oa36cMc-1606022431193)(C:\Users\DELL\AppData\Roaming\Typora\typora-user-images\image-20201122122928208.png)]

优缺点介绍：

1）用枚举来实现单例模式。不仅能避免多线程同步的问题，而且还能防止反序列化重新创建新的对象。

2）这种方式是 java 作者 Josh Bloch提倡的方式

原理：

1️⃣：枚举类的构造器是private私有的，保障了内存中只有枚举的一个实例。

2️⃣：枚举类的实例会在类加载的时候线程安全的进行初始实例化，在类加载的时候，JVM会对()方法加锁，其他线程都需要阻塞等待，直到活动线程执行()方法完毕。需要注意的是，其他线程虽然会被阻塞，但如果执行()方法的那条线程退出()方法后，其他线程唤醒后不会再次进入()方法。同一个类加载器下，一个类型只会初始化一次。

9、单例模式源码举例

1）JDK的 java lang 包下的Runtime类使用的就是饿汉式单例模式

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6OhjS5Y3-1606022431195)(C:\Users\DELL\AppData\Roaming\Typora\typora-user-images\image-20201122130447736.png)]

单例模式总结：

1）单例模式保证了，系统内存中只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统的性能

2）当想实例化一个单例类的时候，必须要记住使用响应的获取对象的方法，而不是使用 new

3）单例模式使用的场景：需要频繁的进行创建和销毁的对象，创建对象时耗时过多或耗费资源过多（即：重量级对象），但又经常用到的对象、工具类对象、频繁访问数据库文件对象（比如数据源、session工厂等）

9、单例模式源码举例

1）JDK的 java lang 包下的Runtime类使用的就是饿汉式单例模式

[外链图片转存中…(img-6OhjS5Y3-1606022431195)]

单例模式总结：

1）单例模式保证了，系统内存中只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统的性能

2）当想实例化一个单例类的时候，必须要记住使用响应的获取对象的方法，而不是使用 new

Conny?

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
设计模式

设计模式之单例模式要了解单例模式，根据博主本人的学习经历，推荐先去搞懂 java中的 final和static关键字的使用，以及类加载过程。分享两篇文章(关于 final和static)https://www.cnblogs.com/shuaiBqi/p/11907908.htmlhttps://blog.csdn.net/qq_41457412/article/details/805987871.单例模式概念：所谓单例模式，就是采取一定的方法保证在整个的软件系统中，对某个类之只能存在一个对象实
复制链接

扫一扫