0
点赞
收藏
分享

微信扫一扫

再谈观察者模式的具体应用，如监听一个class其中一个属性，如websocket中onmessage的实现

不会弹吉他的二郎腿 2023-12-23 阅读 37
设计模式单例模式springjava源码

文章目录

前言

  • 单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
  • 这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

一、单例模式实现

1.饿汉式

静态变量方式

/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: Singleton
 * @Description: 饿汉式静态变量
 * @Date: 2023/12/20 21:56
 */
public class Singleton {
    private Singleton(){}
    private static Singleton instance = new Singleton();

    public static Singleton getInstance() {
        return instance;
    }
}

测试：

/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: Client
 * @Description: 测试类
 * @Date: 2023/12/20 21:57
 */
public class Client {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();

        Singleton instance1 = Singleton.getInstance();

        System.out.println(instance == instance1);//true
    }

}

静态代码块方式

/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: Singleton
 * @Description: 饿汉式（静态代码块）
 * @Date: 2023/12/21 9:16
 */
public class Singleton {
    private Singleton(){}
    private static Singleton instance;

    static {
        instance = new Singleton();
    }

    public static Singleton getInstance(){
        return instance;
    }
}

测试：

/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: Client
 * @Description: 测试类
 * @Date: 2023/12/20 21:57
 */
public class Client {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();

        Singleton instance1 = Singleton.getInstance();

        System.out.println(instance == instance1);//true
    }

}

2.懒汉式

线程不安全

/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: Singleton
 * @Description: 懒汉式（线程不安全）
 * @Date: 2023/12/21 9:24
 */
public class Singleton {
    //私有构造方法
    private Singleton() {}

    //在成员位置创建该类的对象
    private static Singleton instance;

    //对外提供静态方法获取该对象
    public static Singleton getInstance() {

        if(instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

线程安全

/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: Singleton
 * @Description: 懒汉式（线程安全）
 * @Date: 2023/12/21 9:32
 */
public class Singleton {
    //私有构造方法
    private Singleton() {}

    //在成员位置创建该类的对象
    private static Singleton instance;

    //对外提供静态方法获取该对象
    public static synchronized Singleton getInstance() {

        if(instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

双重检查锁

/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: Singleton
 * @Description: 懒汉式（双重检查锁）
 * @Date: 2023/12/21 9:36
 */
public class Singleton {
    //私有构造方法
    private Singleton() {}

    private static Singleton instance;

    //对外提供静态方法获取该对象
    public static Singleton getInstance() {
        //第一次判断，如果instance不为null，不进入抢锁阶段，直接返回实例
        if(instance == null) {
            synchronized (Singleton.class) {
                //抢到锁之后再次判断是否为null
                if(instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: Singleton
 * @Description: 懒汉式（双重检查锁）
 * @Date: 2023/12/21 9:36
 */
public class Singleton {
    //私有构造方法
    private Singleton() {}

    private static volatile  Singleton instance;

    //对外提供静态方法获取该对象
    public static Singleton getInstance() {
        //第一次判断，如果instance不为null，不进入抢锁阶段，直接返回实例
        if(instance == null) {
            synchronized (Singleton.class) {
                //抢到锁之后再次判断是否为null
                if(instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

静态内部类方式

/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: Singleton
 * @Description: 懒汉式（静态内部类）
 * @Date: 2023/12/21 9:42
 */
public class Singleton {
    //私有构造方法
    private Singleton() {}

    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    //对外提供静态方法获取该对象
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

枚举方式

/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: Singleton
 * @Description: 恶汉式（枚举）
 * @Date: 2023/12/21 9:53
 */
public enum Singleton {
    INSTANCE;
}

二、存在问题

1.序列化反序列化

public class Singleton implements Serializable {

    //私有构造方法
    private Singleton() {}

    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    //对外提供静态方法获取该对象
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

public class Test {
    public static void main(String[] args) throws Exception {
        //往文件中写对象 （先运行这个写入，然后注释）
        //writeObject2File();
        //从文件中读取对象（再运行这个读取）
        Singleton s1 = readObjectFromFile();
        Singleton s2 = readObjectFromFile();

        //判断两个反序列化后的对象是否是同一个对象
        System.out.println(s1 == s2);
    }

    private static Singleton readObjectFromFile() throws Exception {
        //创建对象输入流对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("C:\\Users\\Dragon\\Desktop\\a.txt"));
        //第一个读取Singleton对象
        Singleton instance = (Singleton) ois.readObject();

        return instance;
    }

    public static void writeObject2File() throws Exception {
        //获取Singleton类的对象
        Singleton instance = Singleton.getInstance();
        //创建对象输出流
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("C:\\Users\\Dragon\\Desktop\\a.txt"));
        //将instance对象写出到文件中
        oos.writeObject(instance);
    }
}

2.反射破坏

public class Singleton {

    //私有构造方法
    private Singleton() {}
    
    private static volatile Singleton instance;

    //对外提供静态方法获取该对象
    public static Singleton getInstance() {

        if(instance != null) {
            return instance;
        }

        synchronized (Singleton.class) {
            if(instance != null) {
                return instance;
            }
            instance = new Singleton();
            return instance;
        }
    }
}

public class Test {
    public static void main(String[] args) throws Exception {
        //获取Singleton类的字节码对象
        Class clazz = Singleton.class;
        //获取Singleton类的私有无参构造方法对象
        Constructor constructor = clazz.getDeclaredConstructor();
        //取消访问检查
        constructor.setAccessible(true);

        //创建Singleton类的对象s1
        Singleton s1 = (Singleton) constructor.newInstance();
        //创建Singleton类的对象s2
        Singleton s2 = (Singleton) constructor.newInstance();

        //判断通过反射创建的两个Singleton对象是否是同一个对象
        System.out.println(s1 == s2);
    }
}

3.解决

序列化破坏解决

public class Singleton implements Serializable {

    //私有构造方法
    private Singleton() {}

    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    //对外提供静态方法获取该对象
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
    
    /**
     * 下面是为了解决序列化反序列化破解单例模式
     */
    private Object readResolve() {
        return SingletonHolder.INSTANCE;
    }
}

private Object readOrdinaryObject(boolean unshared) throws IOException {
	...
	//isInstantiable 返回true，执行 desc.newInstance()，通过反射创建新的单例类，
    obj = desc.isInstantiable() ? desc.newInstance() : null; 
    ...
    // 在Singleton类中添加 readResolve 方法后 desc.hasReadResolveMethod() 方法执行结果为true
    if (obj != null && handles.lookupException(passHandle) == null && desc.hasReadResolveMethod()) {
    	// 通过反射调用 Singleton 类中的 readResolve 方法，将返回值赋值给rep变量
    	// 这样多次调用ObjectInputStream类中的readObject方法，继而就会调用我们定义的readResolve方法，所以返回的是同一个对象。
    	Object rep = desc.invokeReadResolve(obj);
     	...
    }
    return obj;
}

反射破坏解决

public class Singleton {

    //私有构造方法
    private Singleton() {
        /*
           反射破解单例模式需要添加的代码
        */
        if(instance != null) {
            throw new RuntimeException();
        }
    }
    
    private static volatile Singleton instance;

    //对外提供静态方法获取该对象
    public static Singleton getInstance() {

        if(instance != null) {
            return instance;
        }

        synchronized (Singleton.class) {
            if(instance != null) {
                return instance;
            }
            instance = new Singleton();
            return instance;
        }
    }
}

三、JDK源码解析

通过源码查看使用的单例模式：可以看出Runtime类使用的是饿汉式（静态属性）方式来实现单例模式的。

   public class Runtime {
       private static Runtime currentRuntime = new Runtime();
   
       /**
        * Returns the runtime object associated with the current Java application.
        * Most of the methods of class <code>Runtime</code> are instance
        * methods and must be invoked with respect to the current runtime object.
        *
        * @return  the <code>Runtime</code> object associated with the current
        *          Java application.
        */
       public static Runtime getRuntime() {
           return currentRuntime;
       }
   
       /** Don't let anyone else instantiate this class */
       private Runtime() {}
       ...
   }

使用Runtime类中的方法（主要理解单例模式怎么调用方法）：

   public class RuntimeDemo {
       public static void main(String[] args) throws IOException {
           //获取Runtime类对象
           Runtime runtime = Runtime.getRuntime();
   
           //返回 Java 虚拟机中的内存总量。
           System.out.println(runtime.totalMemory());
           //返回 Java 虚拟机试图使用的最大内存量。
           System.out.println(runtime.maxMemory());
   
           //创建一个新的进程执行指定的字符串命令，返回进程对象
           Process process = runtime.exec("ipconfig");
           //获取命令执行后的结果，通过输入流获取
           InputStream inputStream = process.getInputStream();
           byte[] arr = new byte[1024 * 1024* 100];
           int b = inputStream.read(arr);
           System.out.println(new String(arr,0,b,"gbk"));
       }
   }

总结

以上就是软件设计模式的单例模式的讲解。

举报

相关推荐

点阵（点亮其中一个灯）

单片机c语言物联网

设计模式中一对多的观察者模式

观察者模式JavaScript前端开发

Java常用的设计模式，如单例模式、工厂模式、观察者模式等

java设计模式单例模式

【linux部署jar包以后，只修改其中一个class文件】

javalinux

watch监听一个对象中的属性 - Vue篇

vue.jsjavascript前端

java中一个类的class参数怎么接收

Javajava应用程序后端开发

观察者模式的实现

无人机matlab开发语言

ul下有多个li 选择其中一个

OpenStack云计算

JAVA中一个类只能实现一个接口吗

JAVAjava饼状图Java后端开发

观察者模式在spring中的应用

spring监听器观察者模式javaJava编程语言
0 条评论