系列文章目录
肝一肝设计模式【一】-- 单例模式 传送门
肝一肝设计模式【二】-- 工厂模式 传送门
肝一肝设计模式【三】-- 原型模式 传送门
肝一肝设计模式【四】-- 建造者模式 传送门
肝一肝设计模式【五】-- 适配器模式 传送门
肝一肝设计模式【六】-- 装饰器模式 传送门
肝一肝设计模式【七】-- 代理模式 传送门
肝一肝设计模式【八】-- 外观模式 传送门
文章目录
- 系列文章目录
- 前言
- 一、什么是享元模式
- 二、享元模式中的角色
- 三、举个栗子
- 四、在开源框架中的使用
- 写在最后
前言
本节我们继续分析设计模式中的结构型模式，前文中我们已经分析了适配器模式、装饰器模式、代理模式、外观模式，本节我们来学习一下——享元模式。
一、什么是享元模式
享元模式（Flyweight Pattern），它旨在减少对象的内存消耗，提高应用程序的性能。该模式通过共享尽可能多的细粒度对象来实现这一目标，从而有效地支持大量细粒度的对象。
在享元模式中，对象分为两种类型：内部状态（Intrinsic State）和外部状态（Extrinsic State）。内部状态是对象可以共享的状态，不依赖于对象的上下文，而外部状态是对象特定的、依赖于对象的上下文的状态。
享元模式的核心思想是将对象的状态划分为内部状态和外部状态，并且通过共享内部状态来减少对象的数量。
二、享元模式中的角色
享元模式包含以下几个角色：
- 享元接口（Flyweight）：定义享元对象的接口，通过该接口可以接收和操作外部状态。
- 具体享元（ConcreteFlyweight）：实现享元接口，包含内部状态，可以被共享和复用。具体享元对象需要注意线程安全的处理。
- 享元工厂（FlyweightFactory）：负责创建和管理享元对象，它维护一个享元池（Flyweight Pool），用于存储和复用已经创建的享元对象。当客户端请求一个享元对象时，享元工厂会检查享元池中是否已经存在该对象，如果存在则直接返回，否则创建一个新的享元对象并放入享元池中。
- 客户端（Client）：使用享元模式的对象，通过享元工厂获取享元对象，并根据需要传递外部状态。
三、举个栗子
最近在玩王国之泪，咱们就拿游戏来举个例子。ps：塞尔达是天，任天堂是宇宙的主宰！
在游戏中我们会遇到很多怪物，如果创建每个怪物都包含大量的数据（例如位置、外观、属性等），将会占用大量的内存。
而享元模式可以帮助我们减少内存消耗，提高性能。
上代码：
import java.util.HashMap;
import java.util.Map;
// 怪物接口
interface Monster {
void display();
}
// 具体怪物类
class ConcreteMonster implements Monster {
private String type;
private String image; // 内部状态：怪物图片
public ConcreteMonster(String type) {
this.type = type;
// 加载怪物图片，这里简化为字符串
this.image = "Image_" + type;
}
public void display() {
System.out.println("Type: " + type + ", Image: " + image);
}
}
// 怪物工厂
class MonsterFactory {
private static Map<String, Monster> monsterMap = new HashMap<>();
public static Monster getMonster(String type) {
if (monsterMap.containsKey(type)) {
return monsterMap.get(type);
} else {
Monster monster = new ConcreteMonster(type);
monsterMap.put(type, monster);
return monster;
}
}
}
// 客户端代码
public class Client {
public static void main(String[] args) {
Monster monster1 = MonsterFactory.getMonster("波克布林");
Monster monster2 = MonsterFactory.getMonster("丘丘");
Monster monster3 = MonsterFactory.getMonster("波克布林");
Monster monster4 = MonsterFactory.getMonster("丘丘");
monster1.display(); // Type: 波克布林, Image: Image_波克布林
monster2.display(); // Type: 丘丘, Image: Image_丘丘
monster3.display(); // Type: 波克布林, Image: Image_波克布林
monster4.display(); // Type: 丘丘, Image: Image_丘丘
System.out.println("monster1 == monster3: " + (monster1 == monster3)); // true，内部状态相同的对象被共享
System.out.println("monster2 == monster4: " + (monster2 == monster4)); // true，内部状态相同的对象被共享
}
}
在上述示例中，我们定义了一个怪物接口 Monster，并实现了具体的怪物类 ConcreteMonster。ConcreteMonster 类包含了怪物的类型和内部状态 image，在构造函数中根据类型加载怪物图片。
然后，我们创建了怪物工厂 MonsterFactory，通过该工厂可以获取怪物对象。在工厂中，我们使用一个 monsterMap 来缓存已创建的怪物对象。如果请求的怪物对象已存在于缓存中，则直接返回；否则，创建一个新的怪物对象并存入缓存。
在客户端代码中，我们通过怪物工厂获取了不同类型的怪物对象，并调用 display() 方法展示怪物的信息。注意，相同类型的怪物对象被共享使用，因为它们具有相同的内部状态。
四、在开源框架中的使用
数据库连接池就是一个常见的应用享元模式的例子，其中HikariCP 是一个轻量级、高性能的数据库连接池框架，它在内部使用了享元模式来管理连接对象的复用。
在 HikariCP 的源码中，核心的享元模式应用是在 HikariPool 类中，它是连接池的主要实现。下面是一个简化的代码示例，展示了 HikariPool 中享元模式的部分实现：
public class HikariPool {
// 内部状态：连接对象池
private ConcurrentBag<PoolEntry> poolEntries;
// ...
public Connection getConnection() throws SQLException {
// 从连接池中获取一个可用的连接
PoolEntry entry = poolEntries.borrow(timeoutMs);
return wrapConnection(entry);
}
private Connection wrapConnection(PoolEntry entry) {
// 对连接对象进行包装，添加上下文信息
Connection connection = entry.connection;
// ...
return connection;
}
// ...
private static class PoolEntry {
// 内部状态：数据库连接对象
final Connection connection;
// 外部状态：是否被占用
volatile boolean isMarkedInUse;
// ...
PoolEntry(Connection connection) {
this.connection = connection;
}
// ...
}
}
在上述示例中，HikariPool 类表示连接池的主要实现。poolEntries 是连接对象池，其中的每个元素 PoolEntry 表示一个连接对象。PoolEntry 类中的 connection 属性表示数据库连接对象，而 isMarkedInUse 属性表示连接是否被占用。
当调用 getConnection() 方法时，HikariPool 会从连接池中获取一个可用的连接对象，并调用 wrapConnection() 方法对连接进行包装，添加上下文信息等处理。
在 PoolEntry 类中，connection 属性表示数据库连接对象，而 isMarkedInUse 属性用于标记连接是否被占用。这个外部状态的管理使得连接对象可以在不同的上下文中被复用。
由于源码非常复杂，上述示例只是简化了部分代码，真实的 HikariCP 源码中还包含了许多其他功能和优化策略。
写在最后
享元模式可以有效地节省内存空间，特别是在需要创建大量细粒度对象时。通过共享内部状态，可以减少对象的数量，提高应用程序的性能。然而，享元模式的使用需要权衡内部状态和外部状态的划分，以及对线程安全的处理，因为共享的对象可能被多个线程同时访问。
享元模式的优点：
- 内存优化：享元模式通过共享对象的方式减少了内存的使用。相同的对象只在内存中存储一份，多个相似的对象可以共享相同的状态，从而减少了对象的数量和内存占用。
- 性能提升：由于享元模式减少了对象的数量，从而减少了对象的创建和销毁的开销，提高了系统的性能。特别是在需要大量创建对象的场景下，享元模式可以显著减少系统的开销。
- 状态外部化：享元模式将对象的内部状态和外部状态分离，内部状态共享，外部状态由客户端管理。这样可以简化对象的状态管理，提高系统的可维护性和灵活性。
享元模式的缺点：
- 对象共享可能引发线程安全问题：由于多个线程共享相同的对象，可能需要额外的同步措施来保证线程安全性。在多线程环境下，需要注意对共享对象的访问控制，以避免并发问题。
- 对象共享可能导致代码复杂性增加：享元模式需要对对象的内部状态和外部状态进行区分和管理，可能会增加代码的复杂性。这需要在设计和实现过程中进行权衡和折衷。
