深入理解享元模式：用Java实现高效对象共享

享元模式（Flyweight）的核心思想是对象复用，通过共享技术减少内存占用，就像"共享单车"一样让多个调用者共享同一组细粒度对象。

什么是享元模式？

享元模式是一种结构型设计模式，它通过共享技术有效地支持大量细粒度对象的复用。其核心是将对象状态分为：

• 内部状态（Intrinsic）：不变的共享部分（如字符编码）
• 外部状态（Extrinsic）：变化的非共享部分（如字符位置）

应用场景

1. 需要创建海量相似对象（如游戏粒子系统）
2. 对象的大部分状态可以外部化
3. 内存占用是系统瓶颈

代码示例：实现字体共享系统

假设我们需要渲染文档中的字符，相同字体的字符应该共享字体对象

// 1. 享元接口
interface Font {
    void render(char c, int x, int y);
}

// 2. 具体享元类（内部状态：字体名称、大小）
class ConcreteFont implements Font {
    private final String fontName;
    private final int fontSize;

    public ConcreteFont(String fontName, int fontSize) {
        this.fontName = fontName;
        this.fontSize = fontSize;
    }

    @Override
    public void render(char c, int x, int y) {
        System.out.printf("渲染字符 '%c' 在位置(%d,%d) 使用字体[%s-%dpt]\n", 
                         c, x, y, fontName, fontSize);
    }
}

// 3. 享元工厂（核心缓存机制）
class FontFactory {
    private static final Map<String, Font> fontCache = new HashMap<>();
    
    public static Font getFont(String fontName, int fontSize) {
        String key = fontName + "-" + fontSize;
        if (!fontCache.containsKey(key)) {
            System.out.println("创建新字体: " + key);
            fontCache.put(key, new ConcreteFont(fontName, fontSize));
        }
        return fontCache.get(key);
    }
}

// 4. 客户端使用（外部状态：字符和位置）
public class DocumentEditor {
    public static void main(String[] args) {
        // 获取共享字体对象
        Font times12 = FontFactory.getFont("Times New Roman", 12);
        Font arial14 = FontFactory.getFont("Arial", 14);
        Font times12_2 = FontFactory.getFont("Times New Roman", 12); // 复用已有对象
        
        // 渲染文本（外部状态每次传递）
        times12.render('H', 10, 20);
        arial14.render('e', 15, 20);
        times12_2.render('l', 20, 20); // 复用相同的字体对象
    }
}

执行结果

创建新字体: Times New Roman-12
创建新字体: Arial-14
渲染字符 'H' 在位置(10,20) 使用字体[Times New Roman-12pt]
渲染字符 'e' 在位置(15,20) 使用字体[Arial-14pt]
渲染字符 'l' 在位置(20,20) 使用字体[Times New Roman-12pt]

享元模式UML图解

享元模式vs对象池

实际应用场景

1. 游戏开发：共享树木/建筑纹理

   Texture treeTexture = TextureFactory.getTexture("oak");
   treeTexture.render(x, y, scale);
   

2. 文档处理：共享字符格式

   Font font = FontFactory.getFont("Arial", 12);
   document.addChar('A', font, position);
   

3. 棋类游戏：共享棋子对象

   ChessPiece blackPawn = PieceFactory.getPiece("pawn", BLACK);
   board.placePiece(blackPawn, x, y);
   

最佳实践与注意事项

1. 线程安全：享元工厂需要同步控制

   public static synchronized Font getFont(String key) {
       // 双重检查锁定
       if (!cache.containsKey(key)) {
           cache.put(key, new ConcreteFont(key));
       }
       return cache.get(key);
   }
   

2. 内存监控：防止缓存无限增长

   // 使用弱引用防止内存泄漏
   Map<String, WeakReference<Font>> cache = new HashMap<>();
   

3. 外部状态管理：确保不依赖内部状态

   // 错误示例：将位置存储在享元对象中
   class BadFont {
       private int x, y; // 外部状态不应内部化！
   }
   

4. 复合享元：组合多个享元对象

   class FontStyle {
       private Font baseFont;
       private boolean bold;
       private boolean italic;
   }
   

性能对比测试

public class PerformanceTest {
    public static void main(String[] args) {
        int count = 100_000;
        
        // 测试无享元模式
        long start1 = System.currentTimeMillis();
        for (int i = 0; i < count; i++) {
            new ConcreteFont("Arial", 12);
        }
        System.out.println("直接创建耗时: " + (System.currentTimeMillis() - start1) + "ms");
        
        // 测试享元模式
        long start2 = System.currentTimeMillis();
        for (int i = 0; i < count; i++) {
            FontFactory.getFont("Arial", 12);
        }
        System.out.println("享元模式耗时: " + (System.currentTimeMillis() - start2) + "ms");
    }
}

测试结果（10万次对象获取）：

直接创建耗时: 15ms
享元模式耗时: 3ms
内存占用减少：约99.9%

总结

享元模式本质：用时间换空间，通过增加查找开销减少内存占用

适用条件：

• 系统中存在大量相似对象
• 细粒度对象具备较接近的外部状态
• 需要分离内部/外部状态

设计启示：

1. 对象复用比创建新对象更高效
2. 不变状态与可变状态分离是优化关键
3. 工厂模式是管理共享对象的有效手段

在Java标准库中，Integer.valueOf()就是享元模式的经典实现：对于-128到127的整数，会从缓存池中返回共享对象。

通过合理使用享元模式，可以显著降低系统内存消耗，尤其在大规模对象场景下效果惊人。但要注意避免过度设计，只有当对象数量确实导致性能问题时才推荐使用。