设计模式之单例模式

目录

• 一、简介
• 二、单例模式实现方式
• • 1、饿汉式单例（推荐）
  • • 饿汉式-方式1（**静态变量方式**）
    • 饿汉式-方式2（静态代码块方式）
  • 2、懒汉式单例
  • • 懒汉式-方法1（线程不安全）
    • 懒汉式-方法2（线程安全）
    • 懒汉式-方法3（双重锁结构）
• 三、单例破坏的方式
• • 1、反射攻击
  • 2、序列化攻击
  • 3、克隆攻击
  • 4、防御方式

一、简介

单例模式是oop（面向对象编程）语言的一种概念，顾名思义，就是一个类只能有一个实例对象。

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一，这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

二、单例模式实现方式

单例设计模式分类两种：
饿汉式：类加载就会导致该单实例对象被创建。
懒汉式：类加载不会导致该单实例对象被创建，而是首次使用该对象时才会创建。

1、饿汉式单例（推荐）

饿汉式-方式1（静态变量方式）

这种方法通过将对象的实例设置为静态的方式，保证了该对象的实例，永远只有一份,且该对象的创建在类加载的时候就会立即创建在jvm内存中的方法区，在程序运行期间永久存在，所以当我们的对象太大的时候就会造成一种资源的浪费。（会产生大量类加载之后但是没有使用）

/** * 饿汉式 * 静态变量创建类的对象 */publicclassSingleton{//私有构造方法privateSingleton(){}//在成员位置创建该类的对象privatestaticSingletoninstance=newSingleton();//对外提供静态方法获取该对象publicstaticSingletongetInstance(){returninstance;}}

通过static关键字，在类加载时创建对象。

优化实现：

上述传统方式中，由于类加载时就实例化对象，因此当我们调用这个类的其它静态方法时，也会触发类加载，从而实例化单例独享，会导致空间的暂时浪费。

由于静态内部类中的对象不会默认加载，直到调用了获取该内部类属性的方法。因此可用静态内部类封装静态实例变量。

饿汉式-方式2（静态代码块方式）

对象的创建是在静态代码块中，也是对着类的加载而创建。所以和饿汉式的方式1基本上一样。

/** * 饿汉式-方法2 * 在静态代码块中创建该类对象 */publicclassSingleton{//私有构造方法privateSingleton(){}//在成员位置创建该类的对象privatestaticSingletoninstance;static{instance=newSingleton();}//对外提供静态方法获取该对象publicstaticSingletongetInstance(){returninstance;}}

classSingleton{// 私有构造函数privateSingleton(){}// 静态内部类privatestaticclassSingletonHolder{privatestaticSingletoninstance=newSingleton();}publicstaticSingletongetInstance(){returnSingletonHolder.instance;}}

2、懒汉式单例

懒汉式-方法1（线程不安全）

/** * 懒汉式 * 线程不安全 */publicclassSingleton{//私有构造方法privateSingleton(){}//在成员位置创建该类的对象privatestaticSingletoninstance;//对外提供静态方法获取该对象publicstaticSingletongetInstance(){if(instance==null){instance=newSingleton();}returninstance;}}

懒汉式-方法2（线程安全）

由于可能有多个线程同时要使用对象，因此需要考虑线程安全问题，防止并发访问时生成多个实例。

通常需要加锁来解决并发冲突，是用时间换空间的方案。

/** * 懒汉式 * 线程安全 */publicclassSingleton{//私有构造方法privateSingleton(){}//在成员位置创建该类的对象privatestaticSingletoninstance;//对外提供静态方法获取该对象,并且加锁publicstaticsynchronizedSingletongetInstance(){if(instance==null){instance=newSingleton();}returninstance;}}

懒汉式-方法3（双重锁结构）

双重检查锁模式是一种非常好的单例实现模式，解决了单例、性能、线程安全问题，但是呢，JVM在实例化对象的时候会进行优化和指令重排序操作，在多线程的情况下，就可能会出现空指针问题

对于上述对象的创建主要分为三个部分：

• 分配对象的内存空间。
• 初始化对象。
• 设置instance指针指向对象所在的内存空间。

为了提高性能在JVM在实例化对象的时候会进行优化和指令重排序操作，也就是说有可能将我们上述的第七行和第九行代码进行顺序的交换。

/** * 双重检查方式 */publicclassSingleton{//私有构造方法privateSingleton(){}//使用volatile修饰，禁止重排序privatestaticvolatileSingletoninstance;//对外提供静态方法获取该对象publicstaticSingletongetInstance(){//第一次判断，如果instance不为null，不进入抢锁阶段，直接返回实际if(instance==null){synchronized(Singleton.class){//抢到锁之后再次判断是否为空if(instance==null){instance=newSingleton();}}}returninstance;}}

三、单例破坏的方式

1、反射攻击

publicclassSingleton{privatestaticfinalSingletonINSTANCE=newSingleton();privateSingleton(){// 私有构造}publicstaticSingletongetInstance(){returnINSTANCE;}}// 反射攻击代码：publicclassReflectionAttack{publicstaticvoidmain(String[]args)throwsException{Singletoninstance1=Singleton.getInstance();// 使用反射创建第二个实例Constructor<Singleton>constructor=Singleton.class.getDeclaredConstructor();constructor.setAccessible(true);// 突破私有访问限制Singletoninstance2=constructor.newInstance();System.out.println(instance1==instance2);// false！破坏了单例System.out.println("instance1: "+instance1);System.out.println("instance2: "+instance2);}}

通过类信息进行反射创建。

2、序列化攻击

importjava.io.*;publicclassSingletonimplementsSerializable{privatestaticfinalSingletonINSTANCE=newSingleton();privateSingleton(){}publicstaticSingletongetInstance(){returnINSTANCE;}}// 序列化攻击：publicclassSerializationAttack{publicstaticvoidmain(String[]args)throwsException{Singletoninstance1=Singleton.getInstance();// 序列化ByteArrayOutputStreambaos=newByteArrayOutputStream();ObjectOutputStreamoos=newObjectOutputStream(baos);oos.writeObject(instance1);// 反序列化（会创建新实例！）ByteArrayInputStreambais=newByteArrayInputStream(baos.toByteArray());ObjectInputStreamois=newObjectInputStream(bais);Singletoninstance2=(Singleton)ois.readObject();System.out.println(instance1==instance2);// false！}}

3、克隆攻击

publicclassCloneableSingletonimplementsCloneable{privatestaticfinalCloneableSingletonINSTANCE=newCloneableSingleton();privateCloneableSingleton(){}publicstaticCloneableSingletongetInstance(){returnINSTANCE;}@OverrideprotectedObjectclone()throwsCloneNotSupportedException{returnsuper.clone();// 默认实现会创建新实例}}// 攻击：CloneableSingletoninstance1=CloneableSingleton.getInstance();CloneableSingletoninstance2=(CloneableSingleton)instance1.clone();System.out.println(instance1==instance2);// false！

4、防御方式

// 方法1：使用统一的类加载器（应用类加载器）// 方法2：在getInstance()中检查类加载器publicclassClassLoaderSafeSingleton{privatestaticfinalClassLoaderSafeSingletonINSTANCE=newClassLoaderSafeSingleton();privateClassLoaderSafeSingleton(){// 检查类加载器ClassLoadercl=this.getClass().getClassLoader();if(cl!=ClassLoader.getSystemClassLoader()){thrownewRuntimeException("只能由系统类加载器加载");}}publicstaticClassLoaderSafeSingletongetInstance(){returnINSTANCE;}}