一、享元模式定义
享元模式（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指令
可以看到，实际上Integer a = 1这行代码在执行的时候被翻译成了Intege = Integer.valueOf(1);
2.2 Integer.valueOf方法源码解析
追踪Integer.valueOf方法的源码，最终看到了这样一段代码
其中，IntegerCache.low和IntegerCache.high分别是-128和127
如果Integer a = xxx 中的a的值是-128到127范围内，就从cache常量池中获取缓存的对象。
四、线程安全性问题
享元模式本身并没有提供对线程安全性的保证，因此在多线程环境下使用享元模式时需要考虑线程安全性问题。
由于享元模式的核心思想是共享对象以减少内存占用，多个线程可能会同时访问和修改共享的对象。以下是几个与线程安全性相关的问题和解决方案：
- 共享对象的状态修改：如果多个线程同时修改共享对象的状态，可能会导致竞态条件和不一致的结果。为了避免这种情况，可以使用同步机制（如互斥锁、信号量等）来保护共享对象，确保在任何时候只有一个线程可以访问和修改对象状态。
- 对象池的并发访问：如果多个线程同时从对象池获取对象或将对象放回池中，可能会导致对象池的并发问题，如对象重复获取或丢失。为了解决这个问题，可以使用线程安全的数据结构（如并发集合类）来实现对象池，或者使用锁机制对对象池的访问进行同步。
- 全局共享状态的一致性：享元模式中的共享对象通常会持有一些全局共享的状态，多个线程可能同时访问这些状态并进行修改。为了确保共享状态的一致性，需要使用合适的同步机制（如锁、原子操作等）来保护对共享状态的访问和修改。
举例说明下：
假设有一个在线图书商城，使用享元模式来管理图书的库存。图书的库存是共享的对象，多个线程可以同时访问和修改库存信息。以下是一个简化的例子：
享元类：
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.
注意：本文归作者所有，未经作者允许，不得转载