浅谈设计模式 - 单例模式(一)

简介: 保证一个类仅有一个实例,并提供一个全局访问点

什么是单例模式?


网络异常,图片无法展示
|


介绍


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


单例模式的几个应用场景


  1. SpringBean 默认就是单例的,不过用的是动态代理生成代理对象
  2. 工具类里面,由一个单例保存
  3. 其他需要唯一对象的场景


如何实现单例模式


饿汉式


解释:和名字一般,很饿,所以在使用之前就做好了准备


优点:


  1. 保证单例对象不会重复
  2. 永远不会有重复创建的隐患


缺点:


  1. 如果对象较大比较占用jvm内存空间
  2. 影响性能,带来没有必要的对象创建。


实现代码:


/**
 *
 * 单例模式 - 饿汉式
 * @author zhaoxudong
 * @version 1.0
 * @date 2020/10/27 21:45
 */
public class Hungry {
    private static final Hungry instance = new Hungry();
    public static Hungry getInstance(){
        return instance;
    }
    public static void main(String[] args) {
        Hungry instance = Hungry.getInstance();
        System.err.println(instance);
    }
}


非常简单,在创建之前,旧对对象进行了初始化,其实对于比较小的对象,这种方式在实际的使用过程中最多


懒汉式


解释:犹如一个懒汉,只有在使用到的时候,才进行初始化。


优点:


  1. 可以节省系统资源只有真正使用的时候,才会进行获取
  2. 对于


缺点:


1.如果多线程并发访问会出现多次实例化的问题


实现代码:


package com.zxd.interview.desginpattern.single;
import com.zxd.interview.util.ExecuteUtil;
/**
 * 单例模式 - 懒汉式
 *
 * @author zhaoxudong
 * @version 1.0
 * @date 2020/10/27 21:45
 */
public class Lazy {
    public static void main(String[] args) {
        // 常规多线程
//        for (int i = 0; i < 100; i++) {
//            new TestRunThread().start();
//        }
        try {
            ExecuteUtil.startTaskAllInOnce(50000, new TestRunThread());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
/**
 * 模拟异步请求
 * 模拟十组数据
 */
class TestRunThread extends Thread {
    @Override
    public void run() {
        // 懒汉式第一版
//        int i = LazyVersion1.getInstance().hashCode();
        // 懒汉式第二版
//        int i = LazyVersion2.getInstance1().hashCode();
        // 懒汉式第三版
        int i = LazyVersion2.getInstance2().hashCode();
        System.err.println(i);
    }
}
/**
 * 饿汉式的第一版本
 */
class LazyVersion1 {
    private static LazyVersion1 lazyVersion1;
    public static LazyVersion1 getInstance() {
        if (lazyVersion1 == null) {
            // 验证是否创建多个对象
            try {
                // 模拟在创建对象之前做一些准备工作
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            lazyVersion1 = new LazyVersion1();
        }
        return lazyVersion1;
    }
}
/**
 * 懒汉式的第二版本
 * 1. 直接对整个方法加锁
 * 2. 在局部代码块加锁
 */
class LazyVersion2 {
    /**
      非常重要的点: volatile 避免cpu指令重排序
    */
    private static volatile LazyVersion2 lazyVersion2;
    /**
     * 在方法的整体加入 synchronized
     *
     * @return
     */
    public synchronized static LazyVersion2 getInstance1() {
        if (lazyVersion2 == null) {
            // 验证是否创建多个对象
            try {
                // 模拟在创建对象之前做一些准备工作
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            lazyVersion2 = new LazyVersion2();
        }
        return lazyVersion2;
    }
    /**
     * 在局部代码快加入 synchronized
     *
     * @return
     */
    public static LazyVersion2 getInstance2() {
        if (lazyVersion2 == null) {
            // 验证是否创建多个对象
            try {
                // 模拟在创建对象之前做一些准备工作
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (LazyVersion2.class) {
                if (lazyVersion2 == null) {
                    lazyVersion2 = new LazyVersion2();
                }
            }
        }
        return lazyVersion2;
    }
}


注意点:


  1. volatile 关键字是JDK1.5之后的JMM为了防止CPU指令重排序的问题而加入的一种具体机制
  2. 虽然发生的几率非常小的,但是指令重排序是JVM的本身特点


private static volatile LazyVersion2 lazyVersion2;

静态代码块


和饿汉式差不多,这里不在过多赘述,直接上代码:


实现代码:


/**
 * 静态代码块的形式,实现单例
 *
 * @Author zhaoxudong
 * @Date 2020/10/28 13:28
 **/
public class StaticBlock {
    private static final StaticBlock staticBlock;
    static {
        staticBlock = new StaticBlock();
    }
    public static StaticBlock getInstance() {
        return staticBlock;
    }
}


静态内部类:


优点:


  1. 既可以保证一次加载,又可以保证不出现重复的初始化
  2. 可以用一个大类管理所有的内部类


缺点:


  1. 额外需要多一个内部类
  2. 破坏代码设计模式


实现代码:


package com.zxd.interview.desginpattern.single;
import com.zxd.interview.util.ExecuteUtil;
/**
 * 单例模式 - 静态内部类实现
 *
 * @Author zhaoxudong
 * @Date 2020/10/28 13:35
 **/
public class SingleStaticInner {
    /**
     * 使用内部类来进行后续的构造
     */
    public static class Instatnce {
        private static Instatnce instatnce = new Instatnce();
        public static Instatnce getInstatnce() {
            try {
                // 模拟在创建对象之前做一些准备工作
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return instatnce;
        }
    }
    public static void main(String[] args) throws InterruptedException {
        ExecuteUtil.startTaskAllInOnce(250, new ThreadTest());
    }
}
/**
 * 测试多线程获取对象
 */
class ThreadTest extends Thread {
    @Override
    public void run() {
        System.err.println(SingleStaticInner.Instatnce.getInstatnce());
    }
}


序列化/反序列化的问题:


解释:序列化和反序列化的情况下,会出现问题,因为JAVA的序列化从磁盘读取的时候,会生成新的实例对象,但是这样就会违背单例模式的方式


实现代码:


package com.zxd.interview.desginpattern.single;
import java.io.*;
/**
 * 单例模式 - 序列化与反序列化的问题和解决办法
 * @Author zhaoxudong
 * @Date 2020/10/28 13:55
 **/
public class SingleSerialize {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        SerializeStaticInner instance = SerializeStaticInner.getInstance();
        System.err.println(instance.hashCode());
        // 序列化
        FileOutputStream fileOutputStream = new FileOutputStream("temp");
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
        objectOutputStream.writeObject(instance);
        objectOutputStream.close();
        fileOutputStream.close();
        // 反序列化
        FileInputStream fileInputStream = new FileInputStream("temp");
        ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
        SerializeStaticInner read = (SerializeStaticInner) objectInputStream.readObject();
        objectInputStream.close();
        fileInputStream.close();
        System.err.println(read.hashCode());
    }
    static class SerializeStaticInner implements Serializable{
        private static  SerializeStaticInner serializeStaticInner = new SerializeStaticInner();
        public static SerializeStaticInner getInstance(){
            return serializeStaticInner;
        }
        /**
         * 序列化当中的一个钩子方法
         * 避免序列化和反序列化的对象为新实例破坏单例模式的规则
         */
//        protected Object readResolve(){
//            System.err.println("调用特定的序列化方法");
//            return SerializeStaticInner.serializeStaticInner;
//        }
    }
}


  1. 如果没有readResolve(),那么序列化之后反序列化是会变为一个新的实例,这样会破坏单例模式
  2. 如果存在readResolve(),那么序列化之后的对象就不会出现多个实例


扩展:为什么加入readResolve() 方法就可以避免序列化的问题


下面是关于《effective Java》的解释


网络异常,图片无法展示
|


关于此方法的访问权注意事项


网络异常,图片无法展示
|


扩展:序列化必知:


  • 所有需要网络传输的对象都需要实现序列化接口,通过建议所有的javaBean都实现Serializable接口。
  • 对象的类名、实例变量(包括基本类型,数组,对其他对象的引用)都会被序列化;方法、类变量、transient实例变量都不会被序列化。
  • 如果想让某个变量不被序列化,使用transient修饰。
  • 序列化对象的引用类型成员变量,也必须是可序列化的,否则,会报错。
  • 反序列化时必须有序列化对象的class文件。
  • 当通过文件、网络来读取序列化后的对象时,必须按照实际写入的顺序读取。
  • 单例类序列化,需要重写readResolve()方法;否则会破坏单例原则。
  • 同一对象序列化多次,只有第一次序列化为二进制流,以后都只是保存序列化编号,不会重复序列化。
  • 建议所有可序列化的类加上serialVersionUID 版本号,方便项目升级。


源:


我不会去拾人牙慧,所以这里记录一下


java序列化,看这篇就够了


其他优质文章:


Java实现单例的5种方式

相关文章
|
5月前
|
设计模式 缓存 安全
【设计模式】【创建型模式】单例模式(Singleton)
一、入门 什么是单例模式? 单例模式是一种设计模式,确保一个类只有一个实例,并提供一个全局访问点。它常用于需要全局唯一对象的场景,如配置管理、连接池等。 为什么要单例模式? 节省资源 场景:某些对象创
166 15
|
12月前
|
设计模式 安全 Java
Kotlin教程笔记(57) - 改良设计模式 - 单例模式
Kotlin教程笔记(57) - 改良设计模式 - 单例模式
92 2
|
6月前
|
设计模式 存储 安全
设计模式-单例模式练习
单例模式是Java设计模式中的重要概念,确保一个类只有一个实例并提供全局访问点。本文详解单例模式的核心思想、实现方式及线程安全问题,包括基础实现(双重检查锁)、懒汉式与饿汉式对比,以及枚举实现的优势。通过代码示例和类图,深入探讨不同场景下的单例应用,如线程安全、防止反射攻击和序列化破坏等,展示枚举实现的简洁与可靠性。
112 0
|
7月前
|
设计模式 安全 Java
设计模式:单例模式
单例模式是一种创建型设计模式,确保一个类只有一个实例,并提供全局访问点。它通过私有化构造函数、自行创建实例和静态方法(如`getInstance()`)实现。适用于数据库连接池、日志管理器等需要全局唯一对象的场景。常见的实现方式包括饿汉式、懒汉式、双重检查锁、静态内部类和枚举。线程安全问题可通过`synchronized`或双重检查锁解决,同时需防止反射和序列化破坏单例。优点是避免资源浪费,缺点是可能增加代码耦合度和测试难度。实际开发中应优先选择枚举或静态内部类,避免滥用单例,并结合依赖注入框架优化使用。
|
8月前
|
设计模式 存储 安全
设计模式2:单例模式
单例模式是一种创建型模式,确保一个类只有一个实例,并提供全局访问点。分为懒汉式和饿汉式: - **懒汉式**:延迟加载,首次调用时创建实例,线程安全通过双重检查锁(double check locking)实现,使用`volatile`防止指令重排序。 - **饿汉式**:类加载时即创建实例,线程安全但可能浪费内存。 示例代码展示了如何使用Java实现这两种模式。
132 4
|
10月前
|
设计模式 存储 前端开发
前端必须掌握的设计模式——单例模式
单例模式是一种简单的创建型设计模式,确保一个类只有一个实例,并提供一个全局访问点。适用于窗口对象、登录弹窗等场景,优点包括易于维护、访问和低消耗,但也有安全隐患、可能形成巨石对象及扩展性差等缺点。文中展示了JavaScript和TypeScript的实现方法。
378 13
|
10月前
|
设计模式 安全 Java
Kotlin教程笔记(57) - 改良设计模式 - 单例模式
Kotlin教程笔记(57) - 改良设计模式 - 单例模式
113 2
|
11月前
|
设计模式 Java 数据库连接
Java编程中的设计模式:单例模式的深度剖析
【10月更文挑战第41天】本文深入探讨了Java中广泛使用的单例设计模式,旨在通过简明扼要的语言和实际示例,帮助读者理解其核心原理和应用。文章将介绍单例模式的重要性、实现方式以及在实际应用中如何优雅地处理多线程问题。
143 4
|
11月前
|
设计模式 安全 Java
Kotlin教程笔记(57) - 改良设计模式 - 单例模式
Kotlin教程笔记(57) - 改良设计模式 - 单例模式
|
11月前
|
设计模式 存储 数据库连接
PHP中的设计模式:单例模式的深入理解与应用
【10月更文挑战第22天】 在软件开发中,设计模式是解决特定问题的通用解决方案。本文将通过通俗易懂的语言和实例,深入探讨PHP中单例模式的概念、实现方法及其在实际开发中的应用,帮助读者更好地理解和运用这一重要的设计模式。
112 1