设计模式（十二）：享元模式

Published on 2024-03-14 13:09 in 分类: 博客 with 狂盗一枝梅
分类: 博客

一、享元模式定义

享元模式（Flyweight Pattern）是池技术的重要实现方式，其定义如下：Use sharing to support large numbers of fine-grained objects efficiently.（使用共享对象可有效地支持大量的细粒度的对象。）

所谓的“享元”，其实就是“共享最小单元”的意思。

享元模式的定义为我们提出了两个要求：细粒度的对象和共享对象。我们知道分配太多的对象到应用程序中将有损程序的性能，同时还容易造成内存溢出，那怎么避免呢？就是享元模式提到的共享技术。我们先来了解一下对象的内部状态和外部状态。

要求细粒度对象，那么不可避免地使得对象数量多且性质相近，那我们就将这些对象的信息分为两个部分：内部状态（intrinsic）与外部状态（extrinsic）。

● 内部状态

内部状态是对象可共享出来的信息，存储在享元对象内部并且不会随环境改变而改变。

● 外部状态

外部状态是对象得以依赖的一个标记，是随环境改变而改变的、不可以共享的状态。

享元模式的通用类图如下所示：

享元模式通用类图

● Flyweight：抽象享元角色

它简单地说就是一个产品的抽象类，同时定义出对象的外部状态和内部状态的接口或实现。

● ConcreteFlyweight：具体享元角色

具体的一个产品类，实现抽象角色定义的业务。该角色中需要注意的是内部状态处理应该与环境无关，不应该出现一个操作改变了内部状态，同时修改了外部状态，这是绝对不允许的。

● unsharedConcreteFlyweight：不可共享的享元角色

不存在外部状态或者安全要求（如线程安全）不能够使用共享技术的对象，该对象一般不会出现在享元工厂中。

● FlyweightFactory：享元工厂

职责非常简单，就是构造一个池容器，同时提供从池中获得对象的方法。


可能会有人问，为啥享元模式会叫做"Flyweight Pattern"呢？

享元模式来源于“Flyweight”这个词，Flyweight在英文中特指“轻量级的拳击比赛”，它是拳击运动中的专有名词。延伸到软件设计领域，"flyweight" 一词被用来表示对象的轻量级特性。享元模式的目标是通过共享对象来减少内存占用，将对象设计得轻量级、精简，就像拳击比赛中的最轻量级选手一样。

因此，为了与这个轻量级的概念相对应，享元模式被命名为 "Flyweight Pattern"。这个名称强调了该模式的核心思想，即通过共享对象来降低资源消耗，提高系统的效率和性能。

二、一个例子

为了说清楚享元模式中的各个角色的概念，这里举例说明下：

假设我们正在开发一款文字编辑器，类似于word，这种软件说白了就是专门处理文字的，比如有一个场景，我们选中了一段文字，然后将它的字号设置为36，字体设置为仿宋，还要给它加粗

动画

那我们就知道了，描述一段文本的样式，可以使用字号、字体、和字体粗细来进行描述。

假设，我们又选中了一段文本，需要将它的字号设置为36，字体设置为仿宋，还要给它加粗，该怎么做呢？

很明显，这个和之前的第一段文本设置的样式相同，可以使用格式刷进行格式复制粘贴，站在开发者的角度上来看，假设每次编辑字体格式，我们都要使用一个“字体格式”对象来描述一段文本，那我们后端应该生成一个一模一样的“字体格式”对象来描述后面这一段文本的样式。

实现类图如下

享元模式-享元模式字符格式化功能类图

首先，定义享元接口（Flyweight）：创建一个 TextCharacter 接口，用于定义字符的共享方法，比如 render() 用于渲染字符。

public interface TextCharacter {
    void render();
}

创建具体享元类（ConcreteFlyweight）：实现 TextCharacter 接口，并存储内部状态，如字体、字号和颜色等。

public class ConcreteTextCharacter implements TextCharacter{
    
    private int fontSize;
    private String fontFamily;
    private String fontWeight;

    public ConcreteTextCharacter(int fontSize, String fontFamily, String fontWeight) {
        this.fontSize = fontSize;
        this.fontFamily = fontFamily;
        this.fontWeight = fontWeight;
    }

    @Override
    public void render() {
        System.out.println("Rendering character with fontSize: " + fontSize + ", fontFamily: " + fontFamily + ", fontWeight: " + fontWeight);
    }

    @Override
    public String toString() {
        return "ConcreteTextCharacter{" +
                "fontSize=" + fontSize +
                ", fontFamily='" + fontFamily + '\'' +
                ", fontWeight='" + fontWeight + '\'' +
                '}';
    }
}

创建享元工厂（FlyweightFactory）：负责创建和管理享元对象。它维护一个享元池，用于存储已经创建的享元对象，并根据需要返回相应的享元对象。

public class TextCharacterFactory {

    private Map<String, TextCharacter> characterPool;

    public TextCharacterFactory() {
        characterPool = new HashMap<>();
    }

    public TextCharacter getCharacter(String key) {
        // 如果享元对象不存在，则创建新的享元对象并添加到享元池中
        return characterPool.computeIfAbsent(key, this::createCharacter);
    }

    private TextCharacter createCharacter(String key) {
        // 从 key 中解析出字体、字号和颜色等信息
        String[] split = key.split(":");
        return new ConcreteTextCharacter(Integer.parseInt(split[0]), split[1], split[2]);
    }

    public int poolSize() {
        return characterPool.size();
    }
    
}

最后客户端调用

public class Main {

    public static void main(String[] args) {
        TextCharacterFactory textCharacterFactory = new TextCharacterFactory();
        TextCharacter character = textCharacterFactory.getCharacter("24:宋体:bold");
        System.out.println(character);
        TextCharacter character1 = textCharacterFactory.getCharacter("36:宋体:bold");
        System.out.println(character1);
        TextCharacter character2 = textCharacterFactory.getCharacter("24:宋体:bold");
        System.out.println(character2);

        System.out.println("享元工厂内池大小：" + textCharacterFactory.poolSize());
    }
}

运行结果：

ConcreteTextCharacter{fontSize=24, fontFamily='宋体', fontWeight='bold'}
ConcreteTextCharacter{fontSize=36, fontFamily='宋体', fontWeight='bold'}
ConcreteTextCharacter{fontSize=24, fontFamily='宋体', fontWeight='bold'}
享元工厂内池大小：2

可以看到，获取了三次ConcreteTextCharacter实例，但是池大小最终是2，表示其中有一次请求返回了重用的对象。

三、JDK中的享元模式

像是Integer、String等基本类型包装类都使用了享元模式，即使用了对象池来共享对象。

以Integer为例，我们面试的时候经常会被问这种问题：

1、Integer面试题五连问

第一个问题：

Integer a = new Integer(1);
Integer b = new Integer(1);

问：a == b ？

答案是false，很明显两个都是new出来的对象，结果肯定是false

第二个问题：

int a = 1;
Integer b = new Integer(1);

问：a == b ？

答案是true，因为b会自动拆箱为int。

第三个问题：

Integer a = new Integer(100);
Integer b = 100;

问：a == b？

答案是false，因为非new生成的Integer变量指向的是java常量池中的对象，而new Integer()生成的变量指向堆中新建的对象，两者在内存中的地址不同。

第四个问题：

Integer a = 100;
Integer b = 100;

问：a == b ？

答案是true，对于两个非new生成的Integer对象，进行比较时，如果两个变量的值在区间-128到127之间，则比较结果为true，如果两个变量的值不在此区间，则比较结果为false。

第五个问题：

Integer a = 128;
Integer b = 128;

问：a == b ？

答案是false，原因同上一个问题。

2、Integer中的享元模式

2.1 Integer=1的底层逻辑

从上面的面试题中，可以总结出来Integer问题中最关键的问题：Integer = 1这么简单的一个语句，到底JVM是怎么翻译它的，为啥它和new出来的对象不一样？

我们先准备下一段代码

public class Main {
    public static void main(String[] args) {
        Integer a = 127;
    }
}

先用javac Main.java编译成字节码文件Main.class，然后使用命令javap -c Main.class查看反汇编的底层JVM指令

image-20240314104034252

可以看到，实际上Integer a = 1这行代码在执行的时候被翻译成了Intege = Integer.valueOf(1);

2.2 Integer.valueOf方法源码解析

追踪Integer.valueOf方法的源码，最终看到了这样一段代码

image-20240314104755154

其中，IntegerCache.low和IntegerCache.high分别是-128和127

image-20240314105000934

如果Integer a = xxx 中的a的值是-128到127范围内，就从cache常量池中获取缓存的对象。

四、线程安全性问题

享元模式本身并没有提供对线程安全性的保证，因此在多线程环境下使用享元模式时需要考虑线程安全性问题。

由于享元模式的核心思想是共享对象以减少内存占用，多个线程可能会同时访问和修改共享的对象。以下是几个与线程安全性相关的问题和解决方案：

  1. 共享对象的状态修改：如果多个线程同时修改共享对象的状态，可能会导致竞态条件和不一致的结果。为了避免这种情况，可以使用同步机制（如互斥锁、信号量等）来保护共享对象，确保在任何时候只有一个线程可以访问和修改对象状态。
  2. 对象池的并发访问：如果多个线程同时从对象池获取对象或将对象放回池中，可能会导致对象池的并发问题，如对象重复获取或丢失。为了解决这个问题，可以使用线程安全的数据结构（如并发集合类）来实现对象池，或者使用锁机制对对象池的访问进行同步。
  3. 全局共享状态的一致性：享元模式中的共享对象通常会持有一些全局共享的状态，多个线程可能同时访问这些状态并进行修改。为了确保共享状态的一致性，需要使用合适的同步机制（如锁、原子操作等）来保护对共享状态的访问和修改。

举例说明下：

假设有一个在线图书商城，使用享元模式来管理图书的库存。图书的库存是共享的对象，多个线程可以同时访问和修改库存信息。以下是一个简化的例子：

享元类：

public class Book {
    private String title;
    private String author;
    private int stock; // 图书库存

    public Book(String title, String author, int stock) {
        this.title = title;
        this.author = author;
        this.stock = stock;
    }

    // 省略其他属性的访问方法

    public synchronized boolean isAvailable() {
        return stock > 0;
    }

    public synchronized void borrowBook() {
        if (stock > 0) {
            stock--;
            System.out.println("Borrowed book: " + title);
        } else {
            System.out.println("The book is out of stock: " + title);
        }
    }
}

在这里为了避免出现线程安全性问题，isAvailable方法和borrowBook方法都变成了同步方法。

享元工厂：

public class BookStore {
    private Map<String, Book> bookPool;

    public BookStore() {
        bookPool = new HashMap<>();
    }

    public synchronized Book getBook(String title) {
        Book book = bookPool.get(title);

        if (book == null) {
            // 如果图书不存在，则创建新的图书对象并添加到图书池中
            book = createBook(title);
            bookPool.put(title, book);
        }

        return book;
    }

    private Book createBook(String title) {
        // 根据图书标题从数据库或其他来源获取图书的作者和库存信息
        String author = fetchAuthorFromDatabase(title);
        int stock = fetchStockFromDatabase(title);

        return new Book(title, author, stock);
    }

    private String fetchAuthorFromDatabase(String title) { /* 从数据库获取作者信息的逻辑 */ }

    private int fetchStockFromDatabase(String title) { /* 从数据库获取库存信息的逻辑 */ }
}

总结

1、享元模式的优点和缺点

享元模式是一个非常简单的模式，它可以大大减少应用程序创建的对象，降低程序内存的占用，增强程序的性能，但它同时也提高了系统复杂性，需要分离出外部状态和内部状态，而且外部状态具有固化特性，不应该随内部状态改变而改变，否则导致系统的逻辑混乱。

2、享元模式的使用场景

● 系统中存在大量的相似对象。

● 细粒度的对象都具备较接近的外部状态，而且内部状态与环境无关，也就是说对象没有特定身份。

● 需要缓冲池的场景。

3、对象池类别

需要说明一下的是，使用享元模式可以实现对象池，但是对象池还有不通的类别：

有的对象池着重在对象的复用上（比如数据库连接池、线程池），池中的每个对象是可替换的，从同一个池中获得A对象和B对象对客户端来说是完全相同的，它主要解决复用，而享元模式在主要解决的对象的共享问题，如何建立多个可共享的细粒度对象则是其关注的重点，比如Integer中的常量池则是享元模式更好的体现。



END.


注意：本文归作者所有，未经作者允许，不得转载

#设计模式
阅读全部
目录