设计模式之单例模式笔记

news2024/11/15 11:01:49

设计模式之单例模式笔记

  • 说明
  • Singleton(单例)
  • 目录
  • 单例模式之饿汉式-静态成员变量写法
    • 测试类
  • 单例模式之饿汉式-静态代码块写法
    • 测试类
  • 单例模式之懒汉式-线程不安全写法和线程安全写法
    • 测试类
  • 单例模式之懒汉式-双重检查锁方式(推荐使用的方式)
  • 单例模式之懒汉式-静态内部类方式(推荐使用的方式)
  • 单例模式之饿汉式-枚举类方式(非常推荐使用的方式)
    • 测试类
  • 实现序列化用来演示破坏该单例模式
    • 测试类
    • 解决方法
  • 反射破坏单例模式
    • 测试类
    • 解决方法
  • RuntimeDemo代码

说明

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

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地址
在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/658672.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Mysql数据库之存储引擎（羡慕她人，不如提升自己）

Mysql数据库之存储引擎（羡慕她人，不如提升自己）

一、存储引擎概念 MySQL中的数据用各种不同的技术存储在文件中，每一种技术都使用不同的存储机制、索引技巧、锁定水平并最终提供不同的功能和能力，这些不同的技术以及配套的功能在MySQL中称为存储引擎。 存储引擎是MySQL将数据存储在文件系统中的存储方…
阅读更多...
ELK日志收集系统简述

ELK日志收集系统简述

一、概述 （一）ELK由三个组件构成 ELK是三个开源软件的缩写，分别是Elasticsearch、Logstash、Kibana ELK 架构基本组成 （二）作用 1、日志收集 2、日志分析 3、日志可视化 （三）为什么使用EL…
阅读更多...
计网之应用层

计网之应用层

因特网协议概述 常用协议应用层HTTP（超文本传输协议）、FTP（文件传输协议）、SMTP（简单邮件传输协议）、DNS（域名系统）、DHCP（动态主机配置协议）、SNMP&#xff…
阅读更多...
15-6.自定义组件的代码共享

15-6.自定义组件的代码共享

在微信小程序中使用 behaviors 进行代码共享，功能类似于vue的mixins 每个behavior可以包含一组属性、数据、生命周期函数和方法 每个组件可以引用多个behavior，behavior也可以引用其他的behavior 目录 1 创建behavior 2 使用behavior 3 behavio…
阅读更多...
机器学习融合模型stacking14条经验总结和5个成功案例(互联网最全，硬核收藏)

机器学习融合模型stacking14条经验总结和5个成功案例(互联网最全，硬核收藏)

我看了很多关于融合模型stacking文章，很多作者倾向于赞美融合模型stacking，对其缺点轻描淡写，这容易误导初学者。一叶障目就是这意思。 我的很多学员喜欢用融合模型作为论文或专利创新点，这是一个热门技术。 最近有个同学在论文…
阅读更多...
MySQL：七种 SQL JOINS 的实现（图文详解）

MySQL：七种 SQL JOINS 的实现（图文详解）

MySQL：7种SQL JOINS的实现 前言一、图示表示二、代码举例1、INNER JOIN（内连接）2、LEFT JOIN（左连接）3、RIGHT JOIN（右连接）4、OUTER JOIN（全连接）5、LEFT EXCLUDING JOI…
阅读更多...
微信小程序入门学习02-TDesign中的自定义组件

微信小程序入门学习02-TDesign中的自定义组件

目录 1 显示文本2 自定义组件3 变量定义4 值绑定总结 我们上一篇讲解了TDesign模板的基本用法，如何开始阅读模板。本篇我们讲解一下自定义组件的用法。 1 显示文本 官方模板在顶部除了显示图片外，还显示了一段文字介绍。文字是嵌套在容器组件里&#xf…
阅读更多...
数据库的操作

数据库的操作

前言 在之前的文章中，我们已经了解了什么是数据库，以及为什么有数据库，和数据库有什么作用，有了这些宏观概念之后，本章为大家进一步详细介绍对于数据库在Linux上如何具体操作。 1.创建数据库 1.1创建数据库语法 语法…
阅读更多...
读书：《敏捷软件开发工具----精益开发方法》

读书：《敏捷软件开发工具----精益开发方法》

《敏捷软件开发工具----精益开发方法》（Lean Software Development: An Agile Toolkit）由Mary Poppendieck和Tom Poppendieck合著，2003年出版，尽管已经有20个年头了，但书中的理念和方法仍然具有很高的实践价值&#xf…
阅读更多...
SpringBoot2概览-运维实用篇

SpringBoot2概览-运维实用篇

知识点 使用SpringBoot提供的maven插件可以将工程打包成可执行jar包然后执行&#xff0c;即java –jar xxx.jar&#xff0c;下面的图是MANIFEST.MF文件的内容&#xff1a; <build><plugins><plugin><groupId>org.springframework.boot</groupId>…
阅读更多...
【MySQL】如何速通MySQL（3）

【MySQL】如何速通MySQL（3）

&#x1f4cc;前言&#xff1a;本篇博客介绍如何速通MySQL的第二篇&#xff0c;主要介绍Mysql中主要的基础的入门&#xff0c;学习MySQL之前要先安装好MySQL&#xff0c;如果还没有安装的小伙伴可以看看博主前面的博客&#xff0c;里面有详细的安装教程。或者看一下下面这个链接…
阅读更多...
136-nago

136-nago

PEID查看你程序有没有壳&#xff0c;发现是汇编语言程序 打开程序&#xff0c;我们发现程序是由Nag提示窗口的。 我们先进行去Nag提示。 进入回调函数&#xff0c;进行分析 保存修改到文件。 重新打开文件&#xff0c;我们发现没有Nag窗口。 再次使用OD进行附加进行分析。…
阅读更多...
项目中遇到的问题总结（四）

项目中遇到的问题总结（四）

GateWay和Nginx的相同点和不同点在哪里&#xff1f; Gateway 和 Nginx 都是常见的反向代理服务器&#xff0c;它们的相同点和不同点如下&#xff1a; 相同点&#xff1a; 都可以作为反向代理服务器&#xff0c;接收来自客户端的请求并转发到后端服务器进行处理。 都支持负载均…
阅读更多...
67、C#调用Visual Studio 2019生成的Paddle+OCR(使用ncnn库),去完成业务任务

67、C#调用Visual Studio 2019生成的Paddle+OCR(使用ncnn库),去完成业务任务

基本思想&#xff1a;这里使用飞哥写的android代码&#xff0c;将其取出纯c代码逻辑&#xff0c;自己尝试转了paddleocr模型&#xff0c;可以成功转换&#xff0c;不在详细阐述生成ncnn模型的过程和写后处理ocr识别过程&#xff0c;这里要实现的目的是使用c#调用ncnn的ocr工程&…
阅读更多...
Ps修改文字

Ps修改文字

第一步&#xff1a;打开ps软件&#xff0c;选择菜单栏“文件”中的“打开”选项。 第二步&#xff1a;在弹出的“打开”对话框中&#xff0c;选择一张需要修改文字的图片&#xff0c;单击“打开”按钮。 第三步&#xff1a;在左侧工具栏中&#xff0c;选择“仿制图章工具”。 第…
阅读更多...
【Python 随练】输出 9*9 口诀

【Python 随练】输出 9*9 口诀

题目&#xff1a; 输出 9*9 口诀 简介&#xff1a; 在本篇博客中&#xff0c;我们将使用 Python 代码输出 9*9 口诀表。口诀表是一个常见的数学乘法表格&#xff0c;用于展示从 1 到 9 的乘法结果。我们将给出问题的解析&#xff0c;并提供一个完整的代码示例来生成这个口诀…
阅读更多...
全志V3S嵌入式驱动开发(USB camera驱动）

全志V3S嵌入式驱动开发(USB camera驱动）

【 声明&#xff1a;版权所有&#xff0c;欢迎转载&#xff0c;请勿用于商业用途。 联系信箱&#xff1a;feixiaoxing 163.com】 soc和mcu的一个重要区别&#xff0c;就是soc会涉及到大量的音视频操作&#xff0c;当然音视频也就包括了camera摄像头这部分。v3s本身支持csi接口和…
阅读更多...
webpack优化代码运行之Code split

webpack优化代码运行之Code split

一、 什么是code split Webpack的code split是一种技术&#xff0c;它能够将代码分割成多个块&#xff0c;从而优化应用程序的性能。这样做可以实现按需加载和并行加载&#xff0c;从而减少初始化时间和请求次数。Code split在Webpack中通过使用entry语法和各种Loader和插件来…
阅读更多...
享元模式：减少内存占用的诀窍

享元模式：减少内存占用的诀窍

一&#xff0c;概要 享元模式&#xff08;Flyweight Pattern&#xff09;是一种结构型设计模式&#xff0c;它主要通过共享对象来降低系统中对象的数量&#xff0c;从而减少内存占用和提高程序性能。这听起来有点像单例模式&#xff0c;但它们在实现和用途上有很大的区别。享元…
阅读更多...
JavaScript Day01 初识JavaScript

JavaScript Day01 初识JavaScript

文章目录 1.初识JavaScript1.1.什么是JavaScript1.2.JavaScript的组成部分1.3.JavaScript的历史-JavaScript发展历史-系统环境-编辑器-运行环境-调试&#xff1a; 2. js组成2.1 ECMAScrpt 【js标准】&#xff08;兼容性100%&#xff09; (类似于CoreJava&#xff0c;制定了基础…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023