设计模式之单例模式笔记

已于 2023-06-18 11:11:02 修改
阅读量1k 收藏
点赞数
分类专栏： 设计模式 文章标签： 单例模式 设计模式 java 后端
于 2023-06-18 10:47:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48040732/article/details/131268847
版权

设计模式之单例模式笔记

说明

记录下学习设计模式-单例模式的写法。

Singleton(单例)

意图:保证一个类仅有一个实例，并提供一个访问它的全局访问点。
结构:
在这里插入图片描述
适用性:

  • 当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时。
  • 当这个唯一实例应该是通过子类化可扩展的，并且客户无需更改代码就能使用一个扩展的实例时。

目录

在这里插入图片描述

单例模式之饿汉式-静态成员变量写法

package com.example.deesign_patterns.singleton.demo1;

//单例模式之饿汉式-静态成员变量写法
//缺点:如果该类一直不使用，就会有内存浪费的问题。但是线程是安全的
public class Singleton {

    //1.私有构造方法,防止外部类实例化该类
    private Singleton(){}

    //2.在本类中创建本类对象
    private static Singleton instance=new Singleton();

    //3.提供一个公共的访问方式，让外界获取该对象
    public static Singleton getInstance(){
        return instance;
    }
}

测试类

package com.example.deesign_patterns.singleton.demo1;

public class Client {
    public static void main(String[] args) {
        //创建Singleton类的对象(错误方式),会报错,防止了外部内创建对象
        //Singleton singleton=new Singleton();
        //创建Singleton类的对象(正确方式)
        Singleton singleton1=Singleton.getInstance();
        Singleton singleton2=Singleton.getInstance();
        //判断获取到的2个是否是同一个对象
        System.out.println(singleton1==singleton2);//结果为true,说明是同一个对象
    }
}

在这里插入图片描述

单例模式之饿汉式-静态代码块写法

package com.example.deesign_patterns.singleton.demo2;

//单例模式之饿汉式-静态代码块写法
//缺点:如果该类一直不使用，就会有内存浪费的问题。但是线程是安全的
public class Singleton {

    //1.私有构造方法,防止外部类实例化该类
    private Singleton(){}

    //2.声明Singleton类型的变量
    private static Singleton instance;//初始值为null

    //3.在静态代码块中进行赋值
    static {
        instance=new Singleton();
    }

    //4.提供一个公共的访问方式，让外界获取该对象
    public static Singleton getInstance(){
        return instance;
    }
}

测试类

package com.example.deesign_patterns.singleton.demo2;

public class Client {
    public static void main(String[] args) {
        //创建Singleton类的对象(错误方式),会报错,防止了外部内创建对象
        //Singleton singleton=new Singleton();
        //创建Singleton类的对象(正确方式)
        Singleton singleton1= Singleton.getInstance();
        Singleton singleton2= Singleton.getInstance();
        //判断获取到的2个是否是同一个对象
        System.out.println(singleton1==singleton2);//结果为true,说明是同一个对象
    }
}

在这里插入图片描述

单例模式之懒汉式-线程不安全写法和线程安全写法

package com.example.deesign_patterns.singleton.demo3;

//单例模式之懒汉式-线程不安全写法和线程安全写法
public class Singleton {

    //1.私有构造方法,防止外部类实例化该类
    private Singleton(){}

    //2.声明Singleton类型的变量
    private static Singleton instance;//初始值为null

    //3.提供一个公共的访问方式，让外界获取该对象，线程不安全写法
    //缺点:线程不是安全的，在多线程下可能会创建不同对象，导致对象不是同一个
    /*public static Singleton getInstance(){
        //判断instance是否为null,如果为null,那就创建Singleton类对象,如果有直接返回
        if(instance==null){
            instance=new Singleton();
        }
        return instance;
    }*/

    //3.提供一个公共的访问方式，让外界获取该对象，线程安全写法，加一个synchronized来让方法同步，保证多线程下获取到的是同一个对象
    //缺点:加了同步锁后在大并发量下会影响性能。
    public static synchronized Singleton getInstance(){
        //判断instance是否为null,如果为null,那就创建Singleton类对象,如果有直接返回
        if(instance==null){
            instance=new Singleton();
        }
        return instance;
    }
}

测试类

package com.example.deesign_patterns.singleton.demo3;

public class Client {
    public static void main(String[] args) {
        //创建Singleton类的对象(错误方式),会报错,防止了外部内创建对象
        //Singleton singleton=new Singleton();
        //创建Singleton类的对象(正确方式)
        Singleton singleton1= Singleton.getInstance();
        Singleton singleton2= Singleton.getInstance();
        //判断获取到的2个是否是同一个对象
        System.out.println(singleton1==singleton2);//结果为true,说明是同一个对象
    }
}

在这里插入图片描述

单例模式之懒汉式-双重检查锁方式(推荐使用的方式)

package com.example.deesign_patterns.singleton.demo4;

//单例模式之懒汉式-双重检查锁方式(推荐使用的方式)
//优点:解决了单例、性能、线程安全问题
//缺点:在多线程的情况下，如果不加volatile有可能出现空指针的问题
//改进就是在步骤2那里加一个volatile关键字，保证可见性和有序性就不会出现空指针问题
public class Singleton {

    //1.私有构造方法,防止外部类实例化该类
    private Singleton(){}

    //2.声明Singleton类型的变量
    private static volatile Singleton instance;//初始值为null

    //3.提供一个公共的访问方式，让外界获取该对象
    public static synchronized Singleton getInstance(){
        //第一次判断，如果instance的值不为null，不需要抢占锁，直接返回对象
        if(instance==null){
            synchronized (Singleton.class){
                //第二次判断
                if(instance==null){
                    instance=new Singleton();
                }
            }
        }
        return instance;
    }
}

单例模式之懒汉式-静态内部类方式(推荐使用的方式)

package com.example.deesign_patterns.singleton.demo5;

//单例模式之懒汉式-静态内部类方式(推荐使用的方式)
//静态内部类单例模式中实例由内部类创建，由于JVM在加载外部类的过程中，是不会加载静态内部类的，只有内部类的属性/方法，被调用时才会被加载，并初始化其静态属性。
//静态属性由于被static修饰，保证只被实例化一次，并且严格保证实例化顺序。
public class Singleton {

    //1.私有构造方法,防止外部类实例化该类
    private Singleton(){}

    //2.定义一个静态内部类
    private static class SingletonHolder{
        //在内部类中声明并初始化外部类的对象
        //被final修饰的变量只能被赋值一次，相当于常量
        private static final Singleton INSTANCE=new Singleton();
    }

    //3.提供一个公共的访问方式，让外界获取该对象
    public static Singleton getInstance(){
        return SingletonHolder.INSTANCE;
    }
}

单例模式之饿汉式-枚举类方式(非常推荐使用的方式)

package com.example.deesign_patterns.singleton.demo6;

//单例模式之饿汉式-枚举类方式(非常推荐使用的方式)
//枚举类型是所用单例实现中唯一一种不会被破坏的单例实现模式
public enum Singleton {
    INSTANCE;
}

测试类

package com.example.deesign_patterns.singleton.demo6;

public class Client {
    public static void main(String[] args) {
        //让JVM帮实现单例模式
        Singleton singleton1= Singleton.INSTANCE;
        Singleton singleton2= Singleton.INSTANCE;
        //判断获取到的2个是否是同一个对象
        System.out.println(singleton1==singleton2);//结果为true,说明是同一个对象

    }
}

实现序列化用来演示破坏该单例模式

在单例模式之懒汉式-静态内部类方式中实现Serializable类

package com.example.deesign_patterns.singleton.demo7;

import java.io.Serializable;

//单例模式之懒汉式-静态内部类方式(推荐使用的方式)
//实现序列化用来演示破坏该单例模式
public class Singleton implements Serializable {

    //1.私有构造方法,防止外部类实例化该类
    private Singleton(){}

    //2.定义一个静态内部类
    private static class SingletonHolder{
        //在内部类中声明并初始化外部类的对象
        //被final修饰的变量只能被赋值一次，相当于常量
        private static final Singleton INSTANCE=new Singleton();
    }

    //3.提供一个公共的访问方式，让外界获取该对象
    public static Singleton getInstance(){
        return SingletonHolder.INSTANCE;
    }
}

测试类

先执行writeObject2File()方法在D盘生成一个a.txt文件，然后再执行readObjectFromFile()方法。

package com.example.deesign_patterns.singleton.demo7;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class Client {
    public static void main(String[] args) throws Exception{
        //使用序列化和反序列化破坏单例模式
        //writeObject2File();
        //第一次与第二次对象地址不一样,说明破坏了单例模式
        readObjectFromFile();
        readObjectFromFile();
    }

    //从文件读取数据(对象)
    public static void readObjectFromFile() throws Exception{
        //1.创建对象输入流对象
        ObjectInputStream ois=new ObjectInputStream(new FileInputStream("D:\\a.txt"));
        //2.读取对象
        //JDK1.8版本ObjectInputStream里面的readObject()源码里面1690行点击readOrdinaryObject后看2215行往后的代码有个对象判断如果类中有readResolve()方法就执行这个方法
        Singleton instance= (Singleton) ois.readObject();
        System.out.println("读取对象为="+instance);
        //3.释放资源
        ois.close();
    }

    //向文件中写数据(对象)
    public static void writeObject2File() throws Exception{
        //1.获取Singleton对象
        Singleton instance=Singleton.getInstance();
        //2.创建对象输出流对象(将instance写入到对应目录下a.txt文件里面,文件没有会被自动生成)
        ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("D:\\a.txt"));
        //3.写对象
        oos.writeObject(instance);
        //4.释放资源
        oos.close();
    }
}

发现2个对象地址不一样，说明单例模式被破坏
在这里插入图片描述

解决方法

在Singleton类加上readResolve方法即可，它会自动执行。

package com.example.deesign_patterns.singleton.demo7;

import java.io.Serializable;

//单例模式之懒汉式-静态内部类方式(推荐使用的方式)
//实现序列化用来演示破坏该单例模式
public class Singleton implements Serializable {

    //1.私有构造方法,防止外部类实例化该类
    private Singleton(){}

    //2.定义一个静态内部类
    private static class SingletonHolder{
        //在内部类中声明并初始化外部类的对象
        //被final修饰的变量只能被赋值一次，相当于常量
        private static final Singleton INSTANCE=new Singleton();
    }

    //3.提供一个公共的访问方式，让外界获取该对象
    public static Singleton getInstance(){
        return SingletonHolder.INSTANCE;
    }

    //解决序列化后破坏单例模式方法,只需要加上该方法就可以解决，不需要改动其他任何代码
    //当进行反序列化时，会自动调用该方法，将该方法的返回值直接返回
    //readResolve()方法会被自动调用，需要看ObjectInputStream里面的readObject()方法源码
    public Object readResolve(){
        return SingletonHolder.INSTANCE;
    }
}

重新测试结果:
先执行writeObject2File()方法，在D盘生成一个a.txt文件:
在这里插入图片描述
在这里插入图片描述
重新执行readObjectFromFile()方法结果如下:
在这里插入图片描述

反射破坏单例模式

package com.example.deesign_patterns.singleton.demo7;

//单例模式之懒汉式-静态内部类方式(推荐使用的方式)
//反射破坏单例模式
public class Singleton {

    //1.私有构造方法,防止外部类实例化该类
    private Singleton(){}

    //2.定义一个静态内部类
    private static class SingletonHolder{
        //在内部类中声明并初始化外部类的对象
        //被final修饰的变量只能被赋值一次，相当于常量
        private static final Singleton INSTANCE=new Singleton();
    }

    //3.提供一个公共的访问方式，让外界获取该对象
    public static Singleton getInstance(){
        return SingletonHolder.INSTANCE;
    }
}

测试类

package com.example.deesign_patterns.singleton.demo8;

import java.lang.reflect.Constructor;

public class Client {
    public static void main(String[] args) throws Exception{
        //使用反射破坏单例模式
        //1.获取Singleton的字节码对象
        Class clazz=Singleton.class;
        //2.获取无参构造方法对象(因为Singleton对象构造方法是私有的，所以需要使用下面来获取)
        Constructor  cons= clazz.getDeclaredConstructor();
        //3.取消访问检查
        cons.setAccessible(true);
        //4.创建Singleton对象
        Singleton s1= (Singleton) cons.newInstance();
        Singleton s2= (Singleton) cons.newInstance();
        System.out.println(s1==s2);//结果为false说明破坏了单例模式
    }
}

结果为false说明破坏了单例模式
在这里插入图片描述

解决方法

在Singleton类中的构造方法加同步锁

package com.example.deesign_patterns.singleton.demo8;

//单例模式之懒汉式-静态内部类方式(推荐使用的方式)
//反射破坏单例模式解决方式
public class Singleton {

    private static boolean flag=false;

    //1.私有构造方法,防止外部类实例化该类
    private Singleton(){
        synchronized (Singleton.class){
            //判断flag的值是否是true,如果是true,说明非第一次访问,直接抛一个异常,如果是false,说明第一次访问
            if(flag){
                throw new RuntimeException("不能创建多个对象");
            }
            //将flag的值设置为true
            flag=true;
        }
    }

    //2.定义一个静态内部类
    private static class SingletonHolder{
        //在内部类中声明并初始化外部类的对象
        //被final修饰的变量只能被赋值一次，相当于常量
        private static final Singleton INSTANCE=new Singleton();
    }

    //3.提供一个公共的访问方式，让外界获取该对象
    public static Singleton getInstance(){
        return SingletonHolder.INSTANCE;
    }
}

再次执行Client类的main方法结果如下:
抛出了我们自己设置的异常
在这里插入图片描述

RuntimeDemo代码

Runtime类在JDK源码中是使用的单例模式之饿汉式-静态成员变量写法

package com.example.deesign_patterns.singleton.demo9;

import java.io.IOException;
import java.io.InputStream;

public class RuntimeDemo {

    public static void main(String[] args) throws IOException {
        //获取Runtime类的对象,使用的是饿汉式静态成员变量方式
        Runtime runtime=Runtime.getRuntime();
        //调用runtime的方法exec,参数要的是一个windows命令
        Process process=runtime.exec("ipconfig");
        //调用process对象的获取输入流的方法
        InputStream is = process.getInputStream();
        byte[] arr=new byte[1024*1024*100];
        //读取数据
        int len= is.read(arr);//返回读到的字节的个数
        //将字节数组转换为字符串输出到控制台
        System.out.println(new String(arr,0,len,"GBK"));
    }
}

结果如下:
相当于在windows的cmd控制台执行ipconfig命令查看ip地址
在这里插入图片描述

谁不想飞舞青春
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设计模式之单例模式
maritimesun的专栏
08-07 1152
学习了这么久的设计模式，决定做个总结。看到CSDN博客上也有作者写过一天一个设计模式的，哈哈哈，我惭愧，做不到一天一个，那就两天一个设计模式吧。我力求把每一个模式总结得全面，除了基本原理以外，每个模式的应用场景，以及应该注意的问题等将会有介绍。在此，先特别感谢GOF的《设计模式—可复用面向对象软件的基础》这本书，真的是经典之作，也特别感谢其他已经做过设计模式总结的网友们，有了你们的知识分享，我才会
PHP设计模式之单例模式
浮尘笔记
04-24 550
单例设计模式(Singleton Design Pattern)的意思是：一个类只允许创建一个对象(或者实例)，那这个类就是一个单例类，这种设计模式就叫作单例模式。单例模式可以保证类的对象全局唯一。 “一个类只允许创建唯一一个对象”，那对象的唯一性的作用范围是什么呢? 是指线程内只允许创建一个对象，还是指进程内只允许创建一个对象? 答案是后者，也就是说，单例模式创建的对象是进程唯一的。
尚硅谷设计模式笔记之单例模式
zhengshuangyue的博客
11-19 218
单例设计模式介绍 单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。 单例模式采取一定的方法保证在整个的软件系统中，对某一个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法(静态方法)。 单例设计模式八种方式 饿汉式(静态常量) 饿汉式(静
C#设计模式–单例模式
12-22
　近在学设计模式的一些内容，主要的参考书籍是《Head First 设计模式》，同时在学习过程中也查看了很多博客园中关于设计模式的一些文章的，在这里记录下我的一些学习笔记，一是为了帮助我更深入地理解设计模式，二...
设计模式之美—学习笔记
12-07
在这个“设计模式之美”的学习笔记中，我们将探讨一些主要的设计模式，以及它们在实际开发中的应用。 首先，我们从创建型模式开始。这类模式主要用于对象的创建，如单例模式（Singleton）、工厂模式（Factory ...
23中设计模式—–单例模式
01-20
今天听完狂神说java的单例模式，感慨万分。希望通过这篇文章跟大家一起学习。 1. 饿汉式 [1] 一个私有的构造器 [2] 一个静态变量 [3] 一个静态方法返回对象 饿汉式单例是直接使用静态变量的方式生成这个单例对象...
设计模式笔记设计模式笔记
10-11
设计模式是软件工程中的一种重要概念...以上只是设计模式领域的一小部分知识，设计模式笔记通常会更详细地涵盖每个模式的实现、优缺点、示例代码和实际应用案例，帮助开发者提升设计能力，编写出高质量、可维护的代码。
《C++20设计模式》学习笔记-第5章单例模式
02-05
《C++20设计模式》学习笔记-第5章单例模式
创建型模式-单例模式
Mr丶Yang
07-12 1248
饿汉式-方式1（静态变量方式）说明：​ 该方式在成员位置声明Singleton类型的静态变量，并创建Singleton类的对象instance。instance对象是随着类的加载而创建的。如果该对象足够大的话，而一直没有使用就会造成内存的浪费。饿汉式-方式2（静态代码块方式）说明：​ 该方式在成员位置声明Singleton类型的静态变量，而对象的创建是在静态代码块中，也是对着类的加载而创建。所以和饿汉式的方式1基本上一样，当然该方式也存在内存浪费问题。
设计模式（工厂模式，模板方法模式，单例模式）
最新发布
m0_73966521的博客
07-16 425
这很容易引发线程不安全问题，我们设想有两个线程，第一个线程需要这个singleton1这个对象，进入了if判断，不过这个时候CPU将线程切换给了第二个线程，那这个时候，第二个线程也进入了if判断，然后CPU再切换会第一个线程，线程一创建了对象，但是我们知道线程二也进入了if判断，它也能创建对象，这就导致了线程不安全问题。所以翻译成Java语言就是，空调是一个抽象类，发动机是一个抽象类，多个抽象类，一个工厂抽象类，不同型号的车是一个类都去继承这个工厂，你需要什么零件就去这个工厂里面配这个零件。
总结单例模式的写法
Brenda_Bestow的博客
07-13 686
饿汉模式:线程是安全的,只进行读操作懒汉模式:不安全,有读操作也有写操作单例模式的选择取决于具体需求，如是否需要懒加载、是否需要线程安全等。每种实现方式都有其适用场景和潜在问题，设计时应根据具体情况选择最合适的实现方法。
如何用 Java 实现一个简单的单例模式,怎么处理线程安全问题？
liangzai215的专栏
07-13 442
单例模式是设计模式中的一种，它的核心思想是确保一个类在整个应用程序中只存在一个实例，并提供一个全局访问点来获取这个实例。这在需要控制资源访问、节省系统开销或者协调共享状态的场景下特别有用，比如配置管理器、线程池和数据库连接池等。
单例模式场景模拟和问题解决
我这个代码你能看懂吗？
07-12 395
【代码】单例模式场景模拟和问题解决。
LINUX:懒汉单例模式线程池
W2155的博客
07-16 261
创建一个线程，就是要这个线程去完成某种任务的。池化技术就是，提前创建一批线程，有任务这一批线程就会执行。而不是有任务的时候在去创建线程。池化技术有着更高的效率，因为线程都是提前创建好的，直接执行任务。
【多线程】单例模式
m0_61814277的博客
07-12 1392
本期内容主要介绍单例模式的含义，以及两种实现单例模式的方式，饿汉模式和懒汉模式，其中懒汉模式线程不安全，可以通过加锁将if操作和new操作变成原子操作，通过双重if提高效率，使用volatile关键字禁止指令重排序。
单例模式Singleton
Misnearch的博客
07-13 335
23种设计模式。
单例模式 饿汉式和懒汉式的区别
weixin_51803498的博客
07-16 252
单例模式（Singleton Pattern）是设计模式中最简单、最常见、最容易实现的一种模式。它确保一个类仅有一个实例，并提供一个全局访问点。单例模式主要有两种实现方式：饿汉式（Eager Initialization）和懒汉式（Lazy Initialization）。
设计模式-读书笔记（水印）1
08-04
"这篇读书笔记主要探讨了设计模式的一些核心原则和类间关系，并特别关注了工厂方法模式的介绍和应用场景。" 在设计模式的世界里，有六大基本原则，它们是软件设计的基础。首先，单例职责原则强调一个类应该只做一件...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值