1一乐

V1

2022/06/07阅读:50主题:默认主题

设计模式之---单例模式


☺ 对于单例模式,个人学习需要掌握

  • 注意答案的重点标黑了。对于单例模式,掌握,我下面这几点就很棒棒。

1、知道什么是单例:

答:一个类有且仅有一个实例,[单例],单例模式保证了系统内存中该类只存在一个对象,节省了系统资源,对于一些需要频繁创建销毁的对象,使用单例模式可以提高系统性能。实例化对象的时候,是通过相应的方法,而不是直接new

2、单例模式的意义:节省系统资源

答:[一个类仅仅有一个唯一的对象,并且提供一个全局的访问点],节省系统资源。具体场景:例如公共的全局配置。

公共的全局配置在系统运行时候,就需要加载一些配置和属性,这些配置和属性是一定存在了,又是公共的,同时需要在整个生命周期中都存在,所以只需要一份就行,使用单例模式实现。

3、单例模式的使用场景

答:需要频繁的进行创建和销毁的对象、经常用到的重量级对象(创建对象时耗时很多或耗费资源很多)、工具类对象、频繁访问数据库或文件的对象(比如数据源、session工厂等)

4、单例模式的方式

  • 个人需要掌握:很简单的饿汉式(静态常量/静态代码块)、懒汉式(双重检查)、静态内部类
  • 了解开发中推荐使用的模式饿汉式(静态常量/静态代码块)、双重检查 (懒汉式的改良实用版)、 静态内部类枚举方式
  • 在掌握双重检查的时候,可以先了解一下不推荐在开发使用的懒汉式的三种情况(线程不安全、线程安全[同步方法]、线程安全[同步代码块])
  • 面试写单例模式[饿汉、懒汉]的话,就写写饿汉式(静态常量/静态代码块)懒汉式(双重检查[懒汉式的改良实用版])

5、单例模式利用了jvm的特点[在静态内部类的模式中]

■ 静态内部类优缺点:(利用了jvm的两个特点,起到了懒加载、线程安全的作用)

  • 懒加载:利用了jvm装载的特点:当外部类加载的时候,内部静态类不会被加载,从而保证了懒加载。
  • 线程安全:当类在进行初始化的时候,别的线程是无法进入的。通过类的静态属性只会在第一次加载类的时候初始化,保证了线程安全



一、什么是单例模式:

在java中的定义是:一个类有且仅有一个实例,[单例],并且自行实例化向整个系统提供。

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

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

二、实现单例的步骤:

1、构造器私有化防止new,导致多个实例,而是在类内部创建对象

2、向外暴露一个静态的公共方法 getInstance



三、单例的方式

■ 单例模式有八种方式:

饿汉式(静态常量/静态代码块)

懒汉式(线程不安全/线程安全,同步方法/线程安全,同步代码块)

双重检查

静态内部类

枚举


★ 饿汉式和懒汉式区别:

饿汉式:在类内部一开始初始化时就创建好实例,而懒汉式是需要用的时候才去创建实例



■ 饿汉式(静态常量/静态代码块)

**在开发中推荐使用,尤其是该类的实例会用到,避免了造成内存的浪费**,如果该类的实例不用,则会造成内存的浪费。

/**
* 饿汉式(静态常量)
*/

public class Singleton{
    private static final Singleton singleton  = new Singleton();//饿汉式,初始化时就创建好了实例[使用了final常量-->饿汉式(静态常量)]
    
    private Singleton(){}//构造器私有化,防止new,导致多个实例
    
    public static Singleton getInstance(){//向外暴露一个静态的公共方法  getInstance
        return singleton;
    }
}
/**
* 饿汉式(静态代码块)
*/

public class Singleton{
    private static Singleton singleton  = new Singleton();//饿汉式,初始化时就创建好了实例
    
    //代码块[使用了static代码块-->饿汉式(静态代码块)]
    static{
        singleton = new Singleton();
    }
    
    private Singleton(){}//构造器私有化,防止new,导致多个实例
    
    public static Singleton getInstance(){//向外暴露一个静态的公共方法  getInstance
        return singleton;
    }
}

■ 饿汉式(静态常量) 和 饿汉式(静态代码块) 的优点、缺点:相同

□ 优点:实现较为简单,在类加载时就完成了实例化,避免了多线程同步问题

□ 缺点:在类加载时就完成了实例化(使类加载的情况有很多种,不一定是调用getInstance()方法使类进行加载的),没有达到懒加载的效果。如果程序从始至终未用到该实例,则造成了空间浪费


■ 懒汉式(线程不安全/ 线程安全,同步方法 / 线程安全,同步代码块)

□ 懒汉式(线程不安全)

public class Singleton{
    private Singleton(){}//构造器私有化,防止new,导致多个实例
    private static Singleton singleton;
    public static Singleton getInstance(){//向外暴露一个静态的公共方法  getInstance
        if(singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
    
}

■ 懒汉式(线程不安全) 优缺点:起到懒加载的效果,但是只适合在单线程下使用开发中不推荐使用

□ 线程不安全原因:如果在多线程下,一个线程进入了if (singleton == null)判断语句块,还未来得及往下执行,另一个线程也通过了这个判断语句,这时便会产生多个实例。所以在多线程环境下不可使用这种方式


□ 懒汉式(线程安全,同步方法)

public class Singleton{
    private Singleton(){}//构造器私有化,防止new,导致多个实例
    private static Singleton singleton;
    //同步方法,synchronized直接加在方法上
    public static synchronized Singleton getInstance(){//向外暴露一个静态的公共方法  getInstance
        if(singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }

}

■ 懒汉式(线程安全,同步方法) 优缺点:起到懒加载的效果,线程安全,但是调用效率低开发中不推荐使用


□ 懒汉式(线程安全,同步代码块)

public class Singleton{
    private Singleton(){}//构造器私有化,防止new,导致多个实例
    private static Singleton singleton;
    public static Singleton getInstance(){//向外暴露一个静态的公共方法  getInstance
        if(singleton == null){
            //同步代码块,synchronized是单独作为代码块使用
            synchronized (Singleton.class){
                singleton = new Singleton();
            }     
        }
        return singleton;
    }
}

■ 懒汉式(线程安全,同步代码块) 优缺点:起到懒加载的效果,但是只适合在单线程下使用开发中不推荐使用

□ 线程不安全原因:和 □ 懒汉式(线程不安全)一样。


■ 双重检查

public class Singleton{
    private Singleton(){}//构造器私有化,防止new,导致多个实例
    private static volatile Singleton singleton;
    public static Singleton getInstance(){//向外暴露一个静态的公共方法  getInstance
        //第一层检查
        if(singleton == null){
            //同步代码块
            synchronized (Singleton.class){
                 //第二层检查
                if(singleton == null) {
                    singleton = new Singleton();
                }
            }

        }
        return singleton;
    }

}

双重检查优缺点:解决了同步代码块方式的线程安全问题。

其实就是上面的 □ 懒汉式(线程安全,同步代码块)的优化改良版。

■ 静态内部类

public class Singleton{
    private Singleton(){}//构造器私有化,防止new,导致多个实例
    //静态内部类,在其内部以静态常量的方式实例化对象
    private static class SingletonInstance{
        private static final Singleton singleton = new Singleton();//常量静态属性,实例化对象[初始化]
    }
    public static Singleton getInstance(){//向外暴露一个静态的公共方法  getInstance
        return SingletonInstance.singleton;
    }
}

■ 静态内部类优缺点:(利用了jvm的两个特点,起到了懒加载、线程安全的作用)

  • 懒加载:利用了jvm装载的特点:当外部类加载的时候,内部静态类不会被加载,从而保证了懒加载。
  • 线程安全:当类在进行初始化的时候,别的线程是无法进入的。通过类的静态属性只会在第一次加载类的时候初始化,保证了线程安全。
1.当外部类 Singleton被装载时,静态内部类 SingletonInstance不会被立即装载,实现懒加载
2.当外部类 Singleton调用getInstance()时,静态内部类 SingletonInstance只被装载一次,在初始化静态内部类SingletonInstance的静态常量属性 singleton,保证了线程安全。

■ 枚举方式

enum Singleton{
    INSTANCE;
    public void method(){
//            操作方法
    }

}

■ 枚举方式优缺点: 线程安全,效率高,还可防止反序列化重新创建新的对象.



四、单例的使用场景

需要频繁的进行创建和销毁的对象、

创建对象时耗时过多或 耗费资源过多(即:重量级对象),但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象(比如数据源、session工厂等)



参考内容来源:《尚硅谷Java设计模式(图解+框架源码剖析)》 https://www.bilibili.com/video/BV1G4411c7N4



如果本文对你有帮助的话记得给一乐点个赞哦,感谢!

分类:

后端

标签:

后端

作者介绍

1一乐
V1