首页 > 编程语言 >Java常用设计模式-单例模式

Java常用设计模式-单例模式

时间:2024-07-23 20:56:49浏览次数:14  
标签:序列化 Java signleton Signleton 实例 单例 new 设计模式

Java常用设计模式-单例模式

Java Design Patterns:

创建型模式:工厂方法、抽象方法、建造者、原型、单例

结构型模式有:适配器、桥接、组合、装饰器、外观、享元、代理

行为型模式有:责任链、命令、解释器、迭代器、中介、备忘录、观察者、状态、策略、模板方法、访问者

常用设计模式:

单例模式、工厂模式、代理模式、策略模式&模板模式、门面模式、责任链模式、装饰器模式、组合模式、builder模式

单例模式

简介

确保一个类只有一个实例,并提供一个全局访问点

懒汉式:

/**
 * 单例设计模式:确保一个类只有一个对象实例,并提供一个全局访问点
 * 懒汉式:
 * 是否 Lazy 初始化:是
 * 是否多线程安全:否
 */
public class Signleton {
    private static Signleton signleton;
    private Signleton(){}
    //可以通过synchronized关键字保证线程安全
    public static Signleton getSignleton(){
        if(signleton == null){
            signleton = new Signleton();
        }
        return signleton;
    }
}

饿汉式:

/**
 * 单例设计模式:确保一个类只有一个对象实例,并提供一个全局访问点
 * 饿汉式:
 * 是否 Lazy 初始化:否
 * 是否多线程安全:是
 */
class Signleton1{
    private static Signleton1 signleton1 = new Signleton1();

    private Signleton1(){}

    public static Signleton1 getSignleton1(){
        return signleton1;
    }
}

懒汉式:解决反射、序列化反序列化问题

/**
 * 单例设计模式:确保一个类只有一个对象实例,并提供一个全局访问点
 * 懒汉式:
 * 是否 Lazy 初始化:是
 * 是否多线程安全:否
 */
public class Signleton implements Serializable {
    private static final long serialVersionUID = 1L;
    private static Signleton signleton;

    private Signleton() {
        // 防止反射
        if (signleton != null) {
            throw new RuntimeException();
        }
    }

    // 可以通过synchronized关键字保证线程安全
    public static Signleton getSignleton() {
        if (signleton == null) {
            signleton = new Signleton();
        }
        return signleton;
    }


    /*
    序列化:当一个对象被序列化时,Java 将该对象的状态写入一个字节流。
    反序列化:当字节流被反序列化时,Java 将创建一个新的对象实例,并将字节流中的数据填充到这个新实例中。
    readResolve 方法:在对象被反序列化之后,Java 会调用这个方法。如果该方法存在,返回的对象将代替默认反序列化过程中创建的新对象。
     */
    private Object readResolve() {
        return signleton;
    }

}


 /**
     * 反射测试
     */
    @Test
    public void test(){
        //获取单例
        Signleton signleton = Signleton.getSignleton();
        Signleton signleton1 = Signleton.getSignleton();
        System.out.println(signleton.hashCode());
        System.out.println(signleton1.hashCode());

        //通过反射破坏单例
        try {
            Class<?> aClass = Class.forName("design.patterns.Signleton");
            Constructor<?> declaredConstructor = aClass.getDeclaredConstructor();
            declaredConstructor.setAccessible(true);
            Signleton signleton2 = (Signleton) declaredConstructor.newInstance();
            System.out.println(signleton2.hashCode());
        } catch (ClassNotFoundException | NoSuchMethodException | InstantiationException | IllegalAccessException |
                 InvocationTargetException e) {
            e.printStackTrace();
        }
    }

    /**
     * 序列化测试
     */
    @Test
    public void test1(){
        //获取单例
        Signleton signleton = Signleton.getSignleton();
        Signleton signleton1 = Signleton.getSignleton();
        System.out.println(signleton.hashCode());
        System.out.println(signleton1.hashCode());

        //序列化反序列化获取对象
        try {
            ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("D:/signleton.ser"));
            outputStream.writeObject(signleton1);
            ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("D:/signleton.ser"));
            Signleton signleton2 = (Signleton) inputStream.readObject();
            System.out.println(signleton2.hashCode());
        } catch (IOException | ClassNotFoundException e) {
            // throw new RuntimeException(e);
            e.printStackTrace();
        }
    }

懒汉式DCL(推荐):双重检查锁定(Double-Checked Locking)是用于减少同步开销,同时保证线程安全的一种优化方法。其核心思想是:在访问共享资源时,先进行一次非同步的检查,如果未初始化,再进入同步块进行第二次检查和初始化。这样可以避免每次调用获取实例方法时都需要进行同步,从而提升性能。

这里也确保序列化安全。

/**
 * 单例设计模式:确保一个类只有一个对象实例,并提供一个全局访问点
 * 懒汉式:
 * 是否 Lazy 初始化:是
 * 是否多线程安全:否
 */
public class Signleton implements Serializable {
  	private static final long serialVersionUID = 1L;
    private static volatile Signleton signleton;

    private Signleton() {}

    public static Signleton getSignleton() {
        if (signleton == null) {
        	synchronized(Signleton.class){
        		if(signleton == null){
        		 signleton = new Signleton();
        		}
        	}
           
        }
        return signleton;
    }
    
    /*
    序列化:当一个对象被序列化时,Java 将该对象的状态写入一个字节流。
    反序列化:当字节流被反序列化时,Java 将创建一个新的对象实例,并将字节流中的数据填充到这个新实例中。
    readResolve 方法:在对象被反序列化之后,Java 会调用这个方法。如果该方法存在,返回的对象将代替默认反序列化过程中创建的新对象。
     */
    private Object readResolve() {
        return signleton;
    }
}

场景

资源共享:避免频繁的创建销毁某个对象,造成存好。比如:日志文件。

控制资源:避免过多的对象产生,造成其他问题。比如网站的计数器。

应用场景:

  • 日志管理器:避免频繁创建和销毁日志对象,确保日志文件只被一个实例操作,以便内容可以正确追加。

  • 网站计数器:全局唯一实例用于统计网站访问次数,避免并发更新问题。

  • Windows 回收站:整个系统运行过程中,回收站一直维护着唯一的一个实例。

  • 多线程的线程池:线程池需要方便控制池中的线程,单例模式确保线程池全局唯一。

    • /**
       * 单例线程池 -- 应用场景
       */
      public class ThreadPool1 {
          private static ThreadPool1 threadPool;
          // 定义接口
          private ExecutorService executorService;
      
          private ThreadPool1() {
              executorService = new ThreadPoolExecutor(
                      5, // 核心线程数
                      10, // 总线程数
                      60, TimeUnit.MILLISECONDS, // 存活时间和单位
                      new LinkedBlockingDeque<Runnable>(),  // 用于保存等待执行的任务的队列
                      new ThreadFactory() {  // 用于创建新线程的工厂
                          // 定义原子操作的 int 类型。它可以在多线程环境下安全地进行自增、自减等操作而不需要同步
                          private AtomicInteger threadNumber = new AtomicInteger(1);
                          @Override
                          public Thread newThread(Runnable r) {
                              Thread thread = new Thread(r, "CustomThreadPool-thread-" + threadNumber.getAndIncrement());
                              // thread.setDaemon(true); // 设置为守护线程
                              thread.setPriority(Thread.NORM_PRIORITY);
                              return thread;
                          }
                      },
                      new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略,当任务队列满了且无法再接受任务时的处理策略
              );
      
          }
      
          public static synchronized ThreadPool1 getThreadPool() {
              if (threadPool == null) {
                  threadPool = new ThreadPool1();
              }
              return threadPool;
          }
      
          public void submitTask(Runnable runnable) {
              executorService.submit(runnable);
          }
      
          public void shutdown() {
              executorService.shutdown();
          }
      }
      
      
      
          /**
           * 单例线程池测试
           */
          @Test
          public void test2(){
              Runnable runnable = () -> {
                  System.out.println(Thread.currentThread().getName() + " task is run");
              };
      
              // ThreadPool1.getThreadPool().submitTask(runnable);
      
              ThreadPool1 threadPool = ThreadPool1.getThreadPool();
              threadPool.submitTask(runnable);
              System.out.println(threadPool.hashCode());
      
              ThreadPool1 threadPool1 = ThreadPool1.getThreadPool();
              threadPool1.submitTask(runnable);
              System.out.println(threadPool1.hashCode());
          }
      
      //输出:
      158199555
      158199555
      CustomThreadPool-thread-2 task is run
      CustomThreadPool-thread-1 task is run
      
  • SpringBoot中的大多数容器管理的Bean都是单例的,这些bean是应用程序级别的单例,也就是说不同用户共享同一个实例。比如@RestController、@Service、@Compoment、@Configuration注解修饰的类,默认都是单例。

优点

控制资源的使用

  • 实例控制:确保一个类只有一个实例,避免了多个实例导致的资源浪费。例如,在数据库连接池或线程池的设计中,单例模式确保只创建一个连接池或线程池实例,从而控制资源的使用。
  • 节省资源:减少了系统的开销,避免了重复创建和销毁对象的高昂成本。

全局访问点

  • 统一管理:通过提供一个全局访问点,可以方便地管理和访问实例。比如,在日志记录系统中,通过单例模式可以确保所有日志记录都通过同一个实例进行处理,从而统一日志的输出格式和内容。
  • 一致性:所有对该实例的操作都通过统一的接口进行,确保了数据的一致性和完整性。

易于扩展

  • 延迟实例化:懒汉式单例模式在首次使用时才创建实例,避免了不必要的资源浪费。这种延迟加载的特性也便于在系统启动时减少初始化时间。

缺点

潜在的资源争用

  • 资源竞争:如果单例类内部使用了共享资源,而这些资源在高并发场景下没有妥善处理,可能导致资源竞争问题。例如,某个单例实例持有数据库连接对象,在高并发请求下可能导致连接池枯竭。

单点故障

  • 故障影响范围大:如果单例实例出现问题,整个系统的相关功能可能会受到影响。例如,日志记录系统的单例实例出现异常,可能导致整个系统无法正常记录日志。

难以测试

  • 测试复杂性:由于单例模式在整个应用程序中只有一个实例,单元测试时可能会导致测试的隔离性和独立性变差。例如,一个单例类的状态在多个测试方法之间共享,可能导致测试结果互相影响。

隐藏依赖关系

  • 依赖性不明确:单例模式通过全局访问点访问实例,可能会导致类与类之间的依赖关系变得不清晰。例如,一个类可能隐式依赖于某个单例类的状态,增加了系统的复杂性和维护成本。

标签:序列化,Java,signleton,Signleton,实例,单例,new,设计模式
From: https://www.cnblogs.com/zhiliu/p/18319621

相关文章

  • 2024年最新完整java面试题(含答案)
    1 、面向对象的特征有哪些方面 ? 【基础】答:面向对象的特征主要有以下几个方面:1) 抽象:抽象就是忽略一个主题中与当前目标无关的那些方面,以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题,而只是选择其中的一部分,暂时不用部分细节。抽象包括两个方面,一是......
  • Java基础-学习笔记07
    07Object类详解Object类详解object是所有类的超类,它拥有的方法,其他所有类的对象都会拥有,可以直接使用。equals方法==和equals的对比==是一个比较运算符:既可以判断基本类型(判断的是值是否相等);也可以判断引用类型(判断的是地址是否相等),当两边类型不相等时编译不通过。eq......
  • java学习--运算符
    运算符算术运算符混合运算当进行多类型混合运算时,结果是参与运算的最大类型当只有byteshortintchar四种类型中任意一种或多种进行运算,结果一定是int类型关系运算位运算/逻辑运算位运算进阶 //&也支持两边是数字,转换为二进制进行每位比较,都是1则取1......
  • 使用脚本自动配置Java环境
    python脚本配置java环境适用Windows与LinuxLinux系统的全局配置文件路径:/etc/profile首先需要下载jdk,然后在命令行使用脚本使用方式:jdk路径不带bin目录pythonset_java_env.py/path/to/jdkset_java_env.py内容如下:importosimportsysdefset_java_env(java_path):......
  • Java---String类
    乐观学习,乐观生活,才能不断前进啊!!!我的主页:optimistic_chen我的专栏:c语言,Java欢迎大家访问~创作不易,大佬们点赞鼓励下吧~前言在C语言中已经涉及到字符串了,但是在C语言中要表示字符串只能使用字符数组或者字符指针,可以使用标准库提供的字符串系列函数完成大部分操作,......
  • 创建型模式-单例设计模式
    一、单例设计模式单例模式(SingletonPattern)是Java中最简单的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类,该类负责创建自己的对象,同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式,可......
  • 【Java基础语法】内置接口
    前言:小编紧接着上期抽象类与接口进行了拓展,介绍了一些Java内置有用的接口,希望能够对大家有所帮助。上期博客http://t.csdnimg.cn/0MoDe1.Comparable接口1.1Comparable接口在如下代码中:publicstaticvoidmain(String[]args){Student[]student=newStuden......
  • 使用JavaScript做一个轮播图
    <!DOCTYPEhtml><htmllang="en"><head><metacharset="UTF-8"><metaname="viewport"content="width=device-width,initial-scale=1.0"><title>图片轮播</titl......
  • java中assert用法
    java中assert用法一、java为什么源码框架都用assert调试1、一般是做单元测试的时候用(比如Junit),其它的地方也可以使用,但是基本上没人用,因为在其它的地方判断语句比断言好用。2、如果表达式计算为false,那么系统会报告一个Assertionerror。3、由于assert是一个新关键字,使用老......
  • Java 集合框架:HashMap 的介绍、使用、原理与源码解析
    大家好,我是栗筝i,这篇文章是我的“栗筝i的Java技术栈”专栏的第020篇文章,在“栗筝i的Java技术栈”这个专栏中我会持续为大家更新Java技术相关全套技术栈内容。专栏的主要目标是已经有一定Java开发经验,并希望进一步完善自己对整个Java技术体系来充实自己的......