1、简介

享元模式（Flyweight Pattern）是一种结构型设计模式，用于优化大量相似对象的内存使用。

它通过共享对象来减少内存使用，从而提高程序的性能和效率。享元模式的核心思想是共享对象，也就是将相同或相似的对象共享一份内存空间。

2、🔺对象类型

在享元模式中，通常有两种对象类型：内部状态和外部状态。

内部状态是可以共享的，而外部状态是不可以共享的。

内部状态是指在对象创建时确定并且不会改变的状态，外部状态是指在对象创建之后可能会改变的状态。

通过将相同的内部状态的对象缓存起来，减少了相同内部状态的对象的数量，从而达到减少内存的目的。当需要使用相同内部状态的对象时，只需要从缓存中取出即可。

享元模式的实现需要分离出对象的内部状态和外部状态，然后使用工厂模式来创建和管理对象。

此处为语雀内容卡片，点击链接查看：1、工厂方法 · 语雀

内部状态可以作为享元对象的属性，而外部状态则需要作为方法的参数传入。当需要创建对象时，先检查对象池中是否已经有对应内部状态的对象，如果有则直接返回，如果没有则创建新对象并将其添加到对象池中。在使用对象时，只需要传入外部状态，即可得到完整的对象。

2.1、享元之工厂模式

享元模式使用的是工厂方法模式，而不是抽象工厂模式。

工厂方法模式是一种创建型设计模式，用于定义一个创建对象的接口，但将具体的对象创建延迟到子类中实现。在享元模式中，我们使用了享元工厂类来管理共享对象的创建和缓存，这个工厂类就是工厂方法模式中的工厂。

具体地说，在享元模式中，我们定义了一个 Flyweight 接口，用于定义共享对象的接口；一个具体的享元类 ConcreteFlyweight，用于实现共享对象的具体操作；以及一个享元工厂类 FlyweightFactory，用于管理共享对象的创建和缓存。在享元工厂类中，我们使用工厂方法 getFlyweight 来创建共享对象。

相比之下，抽象工厂模式是一种创建型设计模式，用于定义一系列相关对象的接口，而不需要指定具体的类。在抽象工厂模式中，我们定义了一个抽象工厂类和一组抽象产品类，具体的工厂和产品类是通过实现这些抽象类来实现的。

因此，尽管享元模式和抽象工厂模式都涉及到对象的创建，但它们的目的和实现方式是不同的，因此享元模式使用的是工厂方法模式，而不是抽象工厂模式。

3、组成部分

享元模式包含以下组成部分：

Flyweight（享元）：是抽象享元类或者具体享元类的接口，通过这个接口可以接收外部状态并进行相应的处理。
ConcreteFlyweight（具体享元类）：是实现 Flyweight 接口的具体类，其中存储了享元的内部状态。
UnsharedConcreteFlyweight（非共享具体享元类）：是一些不需要共享的具体享元类，一般情况下很少使用。
FlyweightFactory（享元工厂类）：是负责创建和管理享元对象的工厂类，其中维护了一个享元池用于存储已经创建的享元对象，避免重复创建。
Client（客户端）：是调用享元对象的客户端代码，可以通过享元工厂获取已经创建的享元对象，并将外部状态传递给享元对象进行处理。

这些组成部分共同协作，实现了对象的共享和复用，从而降低了系统的内存消耗和运行时开销。

4、使用场景

享元模式是一种优化内存使用的设计模式，适用于以下场景：

对象数量大且相似：如果一个系统中有大量相似的对象需要被创建，而这些对象的内部状态可以共享，那么可以使用享元模式来减少内存的使用，提高程序的性能和效率。比如说，一个文本编辑器中需要创建大量的字符对象，这些字符对象有很多相同的属性，比如字体和颜色，可以使用享元模式来实现。
内部状态较少：如果一个对象的内部状态较少，那么使用享元模式可以有效地减少内存的使用。比如说，一个围棋游戏中的棋子，它们的内部状态只有颜色和形状，可以使用享元模式来减少内存的使用。
大对象：如果一个对象很大，而系统中需要创建大量的这种对象，那么可以使用享元模式来减少内存的使用。比如说，一个游戏中需要创建大量的怪物对象，而这些对象都包含了很多属性，可以使用享元模式来优化内存使用。
对象的状态可以外部化：如果一个对象的状态可以外部化，那么可以使用享元模式来减少内存的使用。比如说，一个网络聊天室中的用户对象，它们的状态可以外部化，比如说用户名、密码、头像等，可以使用享元模式来优化内存使用。
低延迟要求：如果一个系统需要实现低延迟的操作，那么可以使用享元模式来优化内存使用。由于享元对象已经被缓存起来了，因此可以快速地进行对象的创建和访问，从而实现低延迟的操作。

总之，如果一个系统中有大量相似的对象需要被创建，并且这些对象的内部状态可以共享，那么就可以使用享元模式来优化内存使用，提高程序的性能和效率。

5、优缺点

享元模式是一种优化内存使用的设计模式，它具有以下优点和缺点：

优点：

减少内存使用：使用享元模式可以减少系统中对象的数量，从而减少内存的使用，提高系统的性能和效率。
提高性能：由于享元对象已经被缓存起来了，因此可以快速地进行对象的创建和访问，从而提高系统的性能和效率。
提高可维护性：使用享元模式可以将对象的状态分为内部状态和外部状态，从而提高代码的可维护性。
可以实现对象池：使用享元模式可以实现对象池，从而实现对象的复用，提高系统的性能和效率。

缺点：

增加复杂度：使用享元模式需要将对象的状态分为内部状态和外部状态，这增加了代码的复杂度。
限制状态共享：使用享元模式需要将对象的状态分为内部状态和外部状态，如果对象的状态不能分为内部状态和外部状态，那么就不能使用享元模式。
破坏封装性：使用享元模式需要将对象的状态分为内部状态和外部状态，这可能会破坏对象的封装性。

总之，享元模式是一种优化内存使用的设计模式，它可以减少内存的使用，提高系统的性能和效率，但也有一些缺点，比如增加代码的复杂度、限制状态共享和破坏对象的封装性。在使用享元模式时，需要根据具体的情况权衡优缺点，选择合适的方案。

6、实现

6.1、介绍实现方法

在Java中，享元模式的实现通常使用了单例模式和哈希表来管理对象池。常见的应用场景包括字符串常量池、线程池和数据库连接池等。通过使用享元模式，可以有效地减少内存使用，提高程序性能和效率。

6.1.1、单例

此处为语雀内容卡片，点击链接查看：3、单例 · 语雀

享元模式的实现可以使用单例模式来保证享元工厂类的唯一性。

享元模式中的享元工厂类负责管理共享对象的创建和缓存，因此必须保证该类的唯一性，以避免创建多个实例而导致的资源浪费和数据不一致等问题。一种常用的实现方式是使用单例模式来实现享元工厂类。

在单例模式中，我们使用一个静态变量来保存该类的唯一实例，同时将构造函数设为私有，以避免外部代码创建新的实例。我们可以将享元工厂类的构造函数设为私有，然后提供一个静态方法来获取该类的唯一实例。这样，无论在何时何地调用该方法，都可以得到同一个享元工厂对象的实例。

6.1.2、常用的单例

(享元模式的实现可以使用任何一种单例模式，比较常用的是懒汉式单例模式和双重检查锁单例模式)

此处为语雀内容卡片，点击链接查看：②懒汉式单例 · 语雀

懒汉式单例模式是一种常用的单例模式，其特点是在首次调用 getInstance 方法时才创建唯一实例。在多线程环境下，懒汉式单例模式需要考虑线程安全性问题，可以通过 synchronized 关键字或者静态内部类等方式来解决。

以下是使用懒汉式单例模式实现享元工厂类的示例代码：

1. public class FlyweightFactory {
2. private static FlyweightFactory instance;
3. 
4. // 私有构造函数
5. private FlyweightFactory() {
6. // ...
7.     }
8. 
9. // 静态方法获取唯一实例
10. public static synchronized FlyweightFactory getInstance() {
11. if (instance == null) {
12.             instance = new FlyweightFactory();
13.         }
14. return instance;
15.     }
16. 
17. // 其他方法
18. // ...
19. }

此处为语雀内容卡片，点击链接查看：③双重检查锁单例 · 语雀

双重检查锁单例模式是一种更加高效的单例模式，其特点是通过双重检查来保证线程安全性和效率。在多线程环境下，双重检查锁单例模式可以避免每次调用 getInstance 方法时都加锁的开销，从而提高了程序的性能。

以下是使用双重检查锁单例模式实现享元工厂类的示例代码：

1. public class FlyweightFactory {
2. private static volatile FlyweightFactory instance;
3. 
4. // 私有构造函数
5. private FlyweightFactory() {
6. // ...
7.     }
8. 
9. // 静态方法获取唯一实例
10. public static FlyweightFactory getInstance() {
11. if (instance == null) {
12. synchronized (FlyweightFactory.class) {
13. if (instance == null) {
14.                     instance = new FlyweightFactory();
15.                 }
16.             }
17.         }
18. return instance;
19.     }
20. 
21. // 其他方法
22. // ...
23. }

在上述代码中，我们使用了 volatile 关键字来保证 instance 变量的可见性，避免出现多线程环境下的数据不一致问题。另外，我们使用了双重检查的方式来避免每次调用 getInstance 方法时都加锁的开销，提高了程序的性能。

6.2、demo代码实现

下面是一个简单的 Java 代码实现享元模式的示例：

首先，我们定义一个接口 Flyweight，用于定义共享对象的接口：

1. public interface Flyweight {
2. void operation(String extrinsicState);
3. }

然后，我们定义一个具体的享元类 ConcreteFlyweight，用于实现共享对象的具体操作：

1. public class ConcreteFlyweight implements Flyweight {
2. private String intrinsicState;
3. 
4. public ConcreteFlyweight(String intrinsicState) {
5. this.intrinsicState = intrinsicState;
6.     }
7. 
8. @Override
9. public void operation(String extrinsicState) {
10.         System.out.println("Intrinsic state: " + this.intrinsicState);
11.         System.out.println("Extrinsic state: " + extrinsicState);
12.     }
13. }

在具体的享元类中，我们定义了一个内部状态 intrinsicState，用于存储共享对象的内部状态。在 operation 方法中，我们输出了共享对象的内部状态和外部状态。

接下来，我们定义一个享元工厂类 FlyweightFactory，用于管理共享对象的创建和缓存：

1. public class FlyweightFactory {
2. private Map<String, Flyweight> flyweights = new HashMap<>();
3. 
4. public Flyweight getFlyweight(String intrinsicState) {
5. if (!flyweights.containsKey(intrinsicState)) {
6. Flyweight flyweight = new ConcreteFlyweight(intrinsicState);
7.             flyweights.put(intrinsicState, flyweight);
8.         }
9. return flyweights.get(intrinsicState);
10.     }
11. }

在享元工厂类中，我们定义了一个 flyweights 字典，用于存储共享对象。在 getFlyweight 方法中，我们首先判断字典中是否已经存在对应的共享对象，如果不存在，则创建一个新的共享对象并加入字典，如果存在，则直接返回字典中的共享对象。

最后，我们可以使用如下代码来测试享元模式的实现：

1. public class client {
2. public static void main(String[] args) {
3. FlyweightFactory factory = new FlyweightFactory();
4. Flyweight flyweight1 = factory.getFlyweight("state1");
5. Flyweight flyweight2 = factory.getFlyweight("state1");
6. Flyweight flyweight3 = factory.getFlyweight("state2");
7. 
8.         flyweight1.operation("external state 1");
9.         flyweight2.operation("external state 2");
10.         flyweight3.operation("external state 3");
11. 
12.     }
13. }

在测试代码中，我们首先创建了一个享元工厂类的实例 factory，然后使用 factory.getFlyweight 方法来获取共享对象。我们创建了两个状态相同的共享对象 flyweight1 和 flyweight2，以及一个状态不同的共享对象 flyweight3。最后，我们分别调用了这三个共享对象的 operation 方法，并传递了不同的外部状态。

当我们运行这段代码时，可以看到如下输出结果：

从输出结果可以看出，享元模式可以有效地共享对象，减少内存的使用，提高系统的性能和效率。

设计模式-结构型模式：享元模式