java设计模式一创建型模式一单例模式

已于 2022-09-07 16:01:53 修改
阅读量457 收藏
点赞数 1
分类专栏： java设计模式 # java设计模式一创建型模式 文章标签： 单例模式 java 设计模式
于 2022-07-30 15:54:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_48645407/article/details/126049169
版权
本文详细介绍了Java中实现单例模式的多种方法，包括饿汉式、懒汉式、双重检查、静态内部类和枚举方式。讨论了各种方式的优缺点，如线程安全、延迟加载和内存效率，并强调了单例模式在节省资源和提高性能上的作用。最后，提到了单例模式在实际开发中的应用场景和注意事项。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

单例模式介绍:所谓的单例模式就是采取一定的方法保证在整个的软件系统中,对某个类只能存在一个对象实例,并且该类只提供一个取得其对象实例的方法

文章目录

1饿汉式(静态常量)

步骤如下:

(1)构造器私有化,防止对象被其他类new

(2)在类的内部创建对象

(3)向外暴露一个静态的公共方法.getInstance

(4)代码实现

public class SingleTonTest01 {
  public static void main(String[] args) {
    //测试
    //创建对象实例
    Singleton instance = Singleton.getInstance();
    Singleton instance2 = Singleton.getInstance();
    System.out.println(instance==instance2);//运行结果为true
    System.out.println("instance.hashCode="+instance.hashCode());
    System.out.println("instance2.hashCode="+instance2.hashCode());//我们用hashCode看一下这两个引用变量是否相同,相同即表面这两个是同一个对象实例

  }
}

//饿汉式(静态变量)

class Singleton{
//构造器私有化
private Singleton(){

}

//本类内部创建对象实例
private final static Singleton instance = new Singleton();

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

上面代码就是饿汉式(静态常量)

我们来看一下这种写法的优缺点:

(1)优点:这种写法比较简单,在类装载的时候就完成了实例化(连接-准备阶段赋值),避免线程同步的问题

(2)缺点:在类装载的时候就完成对象实例化,就没有达到Lazy Loading的效果.如果从头到结束都没有用过这个对象实例,就会造成内存的浪费

(3)这种方式基础classloder机制可以避免多线程的同步问题,不过instance在类装载的时候就实例化,在单例模式中大多数都是调用getInstance方法,但是导致类装载的原因有很多,我们不难确定是否又其他的方式导致类装载,所以这种初始化instance就没有达到lazy loading的效果

(4)结论:这种单例模式可用,但是可能会造成内存浪费

2.饿汉式(静态代码块)

步骤如下:

(1)构造器私有化,防止对象被其他类new

(2)在类的内部创建对象

(3)向外暴露一个静态的公共方法.getInstance

(4)代码实现

public class SingleTonTest02 {
public static void main(String[] args) {
    //测试
    Singleton instance = Singleton.getInstance();
    Singleton instance2 = Singleton.getInstance();
    System.out.println(instance==instance2);//true
    System.out.println("instance.hashCode="+instance.hashCode());
    System.out.println("instance2.hashCode="+instance2.hashCode());//hashCode相同即表面这两个是同一个对象实例

}
}

//饿汉式(静态变量)

class Singleton{
//构造器私有化
private Singleton(){
    
}

//本类内部创建对象实例
private static Singleton instance;

static {//在静态代码块中,创建单例对象
    instance = new Singleton();
}

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

我们来看一下这种写法的优缺点:

(1)这种方式跟上面的方式类似,只不过将类实例化的过程放在了静态代码块中,也就是说在类装载的时候,就执行了静态代码块中的代码,初始化实例(初始化阶段赋值).优点跟上面是一样的.

(2)结论:这种单例模式可用,但是可能造成内存浪费

3.懒汉式(线程不安全)

代码演示:

public class SingletonTest03 {
public static void main(String[] args) {
    System.out.println("懒汉式1,线程不安全");
    Singleton instance = Singleton.getInstance();
    Singleton instance2 = Singleton.getInstance();
    System.out.println(instance==instance2);//true
    System.out.println("instance.hashCode="+instance.hashCode());
    System.out.println("instance2.hashCode="+instance2.hashCode());//hashCode相同即表面这两个是同一个对象实例
    
}
}

class Singleton{
private static Singleton instance;

private Singleton(){}

//提供一个静态的公有方法,当使用到该方法,才去创建instance
//即懒汉式
public static Singleton getInstance(){
    if(instance==null){
        instance = new Singleton();
    }
    return instance;
}
}

我们来看一下这种写法的优缺点:

(1)起到了Lazy Loading的效果,但是只能在单线程下使用.

(2)如果在多线程下,一个线程进入了if(singleton==null)判断语句块,还没来的及往下面执行,另外一个线程也通过了这个判断语句,这时便会产生多个实例,所以多线程环境下不可使用这种方式

(3)结论:实际开发中,不要使用这种方式.

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

代码演示:
//这里我就不演示多个线程的测试了,友友们想要看多线程的话自己写写

public class SingleTonTest04 {
public static void main(String[] args) {
    System.out.println("懒汉式2,线程安全");
    Singleton instance = Singleton.getInstance();
    Singleton instance2 = Singleton.getInstance();
    System.out.println(instance==instance2);//true
    System.out.println("instance.hashCode="+instance.hashCode());
    System.out.println("instance2.hashCode="+instance2.hashCode());//hashCode相同即表面这两个是同一个对象实例

}
}

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

class Singleton{

private static Singleton instance;

private Singleton(){}

//提供一个静态的公有方法,加入同步处理的代码,解决线程安全问题
//即懒汉式
public static synchronized Singleton getInstance(){
    if(instance==null){
        instance = new Singleton();
    }
    return instance;
}
}

我们来看一下这种写法的优缺点:

(1)解决了线程不安全问题

(2)效率太低了,每个线程在想获得类的实例的时候,执行getlnstance()方法都要进行同步,这个方法只执行一次实例化代码就够了,后面的想要获得该类的实例时,直接return就行,方法进行同步效率太低了

(3)结论:在实际开发中,不推荐使用这种方法

5.懒汉式(线程不安全,同步代码块)

代码演示:

public class SingleTonTest05 {
public static void main(String[] args) {
    System.out.println("懒汉式3,线程安全");
    Singleton instance = Singleton.getInstance();
    Singleton instance2 = Singleton.getInstance();
    
    System.out.println(instance==instance2);//true
    System.out.println("instance.hashCode="+instance.hashCode());
    System.out.println("instance2.hashCode="+instance2.hashCode());//hashCode相同即表面这两个是同一个对象实例

}
}

class Singleton{
private static Singleton instance;

private Singleton(){}


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

我们来看一下这种写法的优缺点:

(1)这种方式,本意是要对第四种实现方式改进,因为前面同步方法效率太低了,所以想要改为同步产生实例化的代码块

(2)但是这种同步并不能起到线程同步的作业,跟前面第三种实现方式遇到的情形是一致的,假如一个线程进入了if(singleton==null),没来得及往下面执行,另外一个线程也通过了这个判断语句,也就产生了多个实例

(3)结论:实际开发中,不能使用这种方式

6.双重检查

代码演示:

public class SingleTonTest06 {
public static void main(String[] args) {
    Singleton instance = Singleton.getInstance();
    Singleton instance2 = Singleton.getInstance();

    System.out.println(instance==instance2);//true
    System.out.println("instance.hashCode="+instance.hashCode());
    System.out.println("instance2.hashCode="+instance2.hashCode());//hashCode相同即表面这两个是同一个对象实例

}
}

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;
}
}

(1)Double-Check概念是多线程开发中常使用到的,如代码中显示那样,我们进行了两次if(singleton == null)检查,这样就保证了线程安全.

(2)这样写的话,实例化代码只用执行一次,后面再次访问时,判断if(singleton == null),直接return实例化对象,也避免了反复进行方法同步.

(3)线程安全;延迟加载;效率高

(4)结论:实际开发中,可以使用这种单例设计模式.
这里讲一下volatile关键字： 保持内存的可见性–所有线程都能获取的共享内存的最新状态

理解：
不用volatile的状态: 老板让多个人共同完成一件事（初始状态为进行中），假设其中某一个人完成后,事件状态变成了已完成，但是其他人不知道这件事已完成，认为该事件依然处于进行中,这就造成了事情的状态与真实状态不同步的现象。
使用volatile的状态：老板让多个人共同完成一件事（初始状态为进行中），假设其中某一个人完成后，事件状态变成了已完成；此时其他人立刻从老板那接到了事情已完成的通知，于是都明确了这件事已经完成了。

volatile的作用：每次读取前必须先从主存刷新最新的值
每次写入后必须立即同步回主存当中

7.静态内部类

代码演示:

public class SingleTonTest07 {
public static void main(String[] args) {
    Singleton instance = Singleton.getInstance();
    Singleton instance2 = Singleton.getInstance();

    System.out.println(instance==instance2);//true
    System.out.println("instance.hashCode="+instance.hashCode());
    System.out.println("instance2.hashCode="+instance2.hashCode());//hashCode相同即表面这两个是同一个对象实例

}
}

//静态内部类完成
class Singleton{
private static volatile Singleton instance;

//构造器私有化
private Singleton(){}

//写一个静态内部类,该类中有一个静态属性Singleton
private static class SingletonInstance{
    private static final Singleton INSTANCE =new Singleton();
}

//提供一个静态的公有方法,直接放回SingletonInstance.INSTANCE

public static  Singleton getInstance(){
    return SingletonInstance.INSTANCE;
}
}

我们来看一下这种写法的优缺点:

(1)这种方式采用了类装载的机制来保证初始化实例时只有一个线程.

(2)静态内部类方式在Singleton类被装载的时候并不会马上实例化,而是需要实例化的时候,才会调用geInstance方法,才会装载SingleInstance类,从而完成Singleton的实例化.

(3)类的静态属性只会在第一次加载类的时候初始化,所以JVM会帮助我们保证了线程的安全性,在类进行初始化时,别的线程时无法进入的.

(4)优点:避免了线程的不安全性,利用静态内部类特点去实现延迟加载,效率高.

(5)缺点:不能传参

(6)结论:可以使用

8.枚举

代码演示:

public class SingleTonTest08 {
public static void main(String[] args) {
    Singleton instance = Singleton.INSTANCE;
    Singleton instance2 = Singleton.INSTANCE;

    System.out.println(instance==instance2);//true
    System.out.println("instance.hashCode="+instance.hashCode());
    System.out.println("instance2.hashCode="+instance2.hashCode());//hashCode相同即表面这两个是同一个对象实例

    instance.sayOK();

}
}
//枚举,可以实现单例
enum  Singleton{
INSTANCE;
public void sayOK(){
    System.out.println("ok");
}
}

我们来看一下这种写法的优缺点:

(1)借助了JDK1.5中添加的枚举来实现单例模式,不仅避免了多线程的同步问题,而且还能防止反序列化重新创建新的对象.

(2)这种方式是java之父提倡的方式

(3)结论:推荐使用,枚举方式属于饿汉式方式.

有关单例模式的写法都介绍完了,下面我们来看一下单例模式注意事项和细节说明:

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

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

(3)单例模式使用的场景:需要频繁的进行创建和销毁的对象、创建对象时消耗过多或耗费的资源过多,但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象.

这篇文章到这里就结束了,下期会讲解序列化和反射破坏单例模式和相应的解决方案.

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值