系列文章目录

肝一肝设计模式【一】-- 单例模式 传送门
肝一肝设计模式【二】-- 工厂模式 传送门
肝一肝设计模式【三】-- 原型模式 传送门
肝一肝设计模式【四】-- 建造者模式 传送门
肝一肝设计模式【五】-- 适配器模式 传送门
肝一肝设计模式【六】-- 装饰器模式 传送门
肝一肝设计模式【七】-- 代理模式 传送门
肝一肝设计模式【八】-- 外观模式 传送门

前言

本节我们继续分析设计模式中的结构型模式，前文中我们已经分析了适配器模式、装饰器模式、代理模式、外观模式，本节我们来学习一下——享元模式。

一、什么是享元模式

享元模式（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 源码中还包含了许多其他功能和优化策略。

写在最后

享元模式可以有效地节省内存空间，特别是在需要创建大量细粒度对象时。通过共享内部状态，可以减少对象的数量，提高应用程序的性能。然而，享元模式的使用需要权衡内部状态和外部状态的划分，以及对线程安全的处理，因为共享的对象可能被多个线程同时访问。

享元模式的优点：

• 内存优化：享元模式通过共享对象的方式减少了内存的使用。相同的对象只在内存中存储一份，多个相似的对象可以共享相同的状态，从而减少了对象的数量和内存占用。
• 性能提升：由于享元模式减少了对象的数量，从而减少了对象的创建和销毁的开销，提高了系统的性能。特别是在需要大量创建对象的场景下，享元模式可以显著减少系统的开销。
• 状态外部化：享元模式将对象的内部状态和外部状态分离，内部状态共享，外部状态由客户端管理。这样可以简化对象的状态管理，提高系统的可维护性和灵活性。

享元模式的缺点：

• 对象共享可能引发线程安全问题：由于多个线程共享相同的对象，可能需要额外的同步措施来保证线程安全性。在多线程环境下，需要注意对共享对象的访问控制，以避免并发问题。
• 对象共享可能导致代码复杂性增加：享元模式需要对对象的内部状态和外部状态进行区分和管理，可能会增加代码的复杂性。这需要在设计和实现过程中进行权衡和折衷。