一文搞懂“享元模式”到底是什么？

Posted 2022-05-31 公众号JavaEdge

1 简介

Flyweight Design Pattern，结构型模式。享元模式中的“享元”指被共享的单元。享元模式通过复用对象，以达到节省内存的目的。

用于减少创建对象的数量，以减少内存占用和提高性能。尝试复用现有的同类对象，如果未找到匹配的对象，则创建新对象。

意图：运用共享技术有效地支持大量细粒度的对象。

主要解决：在有大量对象时，有可能会造成内存溢出，我们把其中共同的部分抽象出来，如果有相同的业务请求，直接返回在内存中已有的对象，避免重新创建。

2 优点

大大减少对象的创建，降低系统的内存，使效率提高。

3 缺点

提高了系统的复杂度，需要分离出外部状态和内部状态，而且外部状态具有固有化的性质，不应该随着内部状态的变化而变化，否则会造成系统的混乱。

4 适用场景

1、系统中有大量对象 2、这些对象消耗大量内存 3、这些对象的状态大部分可以外部化。 4、这些对象可以按照内蕴状态分为很多组，当把外蕴对象从对象中剔除出来时，每一组对象都可以用一个对象来代替 5、系统不依赖于这些对象身份，这些对象是不可分辨的。

如何解决：用唯一标识码判断，如果在内存中有，则返回这个唯一标识码所标识的对象。

关键代码：用 HashMap 存储这些对象。

应用实例： 1、String，若有则返回，无则创建一个字符串保存在字符串缓存池 2、数据库的数据池。

1、系统有大量相似对象 2、需要缓冲池的场景

这些类必须有一个工厂对象加以控制

5 原理

“享元”，被共享的单元，即复用对象，节省内存，注意前提是享元对象是不可变对象。

当一个系统中存在大量重复对象，若这些重复的对象是不可变对象，就能利用享元模式将对象设计成享元，在内存中只保留一份实例，供引用。这就减少内存中对象的数量，最终节省内存。

不仅相同对象可设计成享元，相似对象，也能提取对象中的相同部分（字段）设计成享元。

“不可变对象”：一旦通过构造器初始化完成后，其状态（对象的成员变量或属性）就不会再被修改。所以，不可变对象不能暴露任何set()等修改内部状态的方法。之所以要求享元是不可变对象，是因为它会被多处代码共享使用，避免一处代码对享元进行了修改，影响到其他使用它的代码。

6 案例

6.1 象棋

一个游戏厅中有成千上万个“房间”，每个房间对应一个棋局。棋局要保存每个棋子的数据，比如：棋子类型（将、相、士、炮等）、棋子颜色（红方、黑方）、棋子在棋局中的位置。利用这些数据，我们就能显示一个完整的棋盘给玩家。具体的代码如下所示:

• ChessPiece类表示棋子
• ChessBoard类表示一个棋局，里面保存了象棋中30个棋子的信息

为记录每个房间当前的棋局情况，要给每个房间都创建一个ChessBoard棋局对象。因为游戏大厅中有成千上万房间，保存这么多棋局对象就会消耗大量内存。如何节省内存呢？

就得用上享元模式啦。在内存中有大量相似对象。这些相似对象的id、text、color都一样，仅positionX、positionY不同。将棋子的id、text、color属性拆出来，设计成独立类，并且作为享元供多个棋盘复用。棋盘只需记录每个棋子的位置信息：

利用工厂类缓存ChessPieceUnit信息（也就是id、text、color）。通过工厂类获取到的ChessPieceUnit就是享元。所有的ChessBoard对象共享这30个ChessPieceUnit对象（因为象棋中只有30个棋子）。在使用享元模式之前，记录1万个棋局，我们要创建30万（30*1万）个棋子的ChessPieceUnit对象。利用享元模式，我们只需要创建30个享元对象供所有棋局共享使用即可，大大节省了内存。

主要通过工厂模式，在工厂类中，通过Map缓存已创建过的享元对象，达到复用。

6.2 文本编辑器

假设该文本编辑器只实现文字编辑功能，不包含图片、表格等编辑。简化后的文本编辑器，要在内存中表示一个文本文件，只需记录文字和格式两部分信息。格式又包括文字的字体、大小、颜色等。

一般按文本类型（标题、正文……）设置文字格式，标题是一种格式，正文是另一种格式。但理论上，可以给文本文件中的每个文字都设置不同格式。为实现如此灵活的格式设置，并且代码实现又不太复杂，把每个文字都当作一个独立对象，并且在其中包含它的格式信息：

文本编辑器中，每敲一个字，就会调用Editor#appendCharacter()，创建一个新Character对象，保存到chars数组。若一个文本文件中，有上万、十几万、几十万的文字，就得在内存存储大量Character对象，如何节省一点内存？

其实一个文本文件中，用到的字体格式不多，毕竟不可能有人把每个文字都设置成不同格式吧。所以，字体格式可设计成享元，让不同文字共享：

public class CharacterStyle 
   
   private Font font;
   
   private int size;
   
   private int colorRGB;
 
   @Override
   public boolean equals(Object o) 
     CharacterStyle otherStyle = (CharacterStyle) o;
     return font.equals(otherStyle.font)
             && size == otherStyle.size
             && colorRGB == otherStyle.colorRGB;
   
 
 
 public class CharacterStyleFactory 
   private static final List styles = new ArrayList<>();
 
   public static CharacterStyle getStyle(Font font, int size, int colorRGB) 
     CharacterStyle newStyle = new CharacterStyle(font, size, colorRGB);
     for (CharacterStyle style : styles) 
       if (style.equals(newStyle)) 
         return style;
       
     
     styles.add(newStyle);
     return newStyle;
   
 
 
 public class Character 
   
   private char c;
   
   private CharacterStyle style;
 
 
 public class Editor 
   private List chars = new ArrayList<>();
 
   public void appendCharacter(char c, Font font, int size, int colorRGB) 
     Character character = new Character(c, CharacterStyleFactory.getStyle(font, size, colorRGB));
     chars.add(character);
   
 

6.3 Shape

我们将创建一个 Shape 接口和实现了 Shape 接口的实体类 Circle。下一步是定义工厂类 ShapeFactory。

ShapeFactory 有一个 Circle 的 HashMap，其中键名为 Circle 对象的颜色。无论何时接收到请求，都会创建一个特定颜色的圆。ShapeFactory 检查它的 HashMap 中的 circle 对象，如果找到 Circle 对象，则返回该对象，否则将创建一个存储在 hashmap 中以备后续使用的新对象，并把该对象返回到客户端。

FlyWeightPatternDemo，我们的演示类使用 ShapeFactory 来获取 Shape 对象。它将向 ShapeFactory 传递信息（red / green / blue/ black / white），以便获取它所需对象的颜色。

享元模式的 UML 图 步骤 1 创建一个接口。

public interface Shape 
    void draw();
 

步骤 2 创建实现接口的实体类。

@Data
 public class Circle implements Shape 
    private String color;
    private int x;
    private int y;
    private int radius;
  
    public Circle(String color)
       this.color = color;     
    
    
    @Override
    public void draw() 
       System.out.println("Circle: Draw() [Color : " + color 
          +", x : " + x +", y :" + y +", radius :" + radius);
    
 

步骤 3 创建一个工厂，生成基于给定信息的实体类的对象。

import java.util.HashMap;
  
 public class ShapeFactory 
    private static final HashMap circleMap = new HashMap<>();
  
    public static Shape getCircle(String color) 
       Circle circle = (Circle)circleMap.get(color);
  
       if(circle == null) 
          circle = new Circle(color);
          circleMap.put(color, circle);
          System.out.println("Creating circle of color : " + color);
       
       return circle;
    
 

步骤 4 使用该工厂，通过传递颜色信息来获取实体类的对象。

public class FlyweightPatternDemo 
    private static final String colors[] = 
        "Red", "Green", "Blue", "White", "Black" ;
    public static void main(String[] args) 
  
       for(int i=0; i < 20; ++i) 
          Circle circle = 
             (Circle)ShapeFactory.getCircle(getRandomColor());
          circle.setX(getRandomX());
          circle.setY(getRandomY());
          circle.setRadius(100);
          circle.draw();
       
    
    private static String getRandomColor() 
       return colors[(int)(Math.random()*colors.length)];
    
    private static int getRandomX() 
       return (int)(Math.random()*100 );
    
    private static int getRandomY() 
       return (int)(Math.random()*100);
    
 

步骤 5 执行程序，输出结果：

Creating circle of color : Black
 Circle: Draw() [Color : Black, x : 36, y :71, radius :100
 Creating circle of color : Green
 Circle: Draw() [Color : Green, x : 27, y :27, radius :100
 Creating circle of color : White
 Circle: Draw() [Color : White, x : 64, y :10, radius :100
 Creating circle of color : Red
 Circle: Draw() [Color : Red, x : 15, y :44, radius :100
 Circle: Draw() [Color : Green, x : 19, y :10, radius :100
 Circle: Draw() [Color : Green, x : 94, y :32, radius :100
 Circle: Draw() [Color : White, x : 69, y :98, radius :100
 Creating circle of color : Blue
 Circle: Draw() [Color : Blue, x : 13, y :4, radius :100
 Circle: Draw() [Color : Green, x : 21, y :21, radius :100
 Circle: Draw() [Color : Blue, x : 55, y :86, radius :100
 Circle: Draw() [Color : White, x : 90, y :70, radius :100
 Circle: Draw() [Color : Green, x : 78, y :3, radius :100
 Circle: Draw() [Color : Green, x : 64, y :89, radius :100
 Circle: Draw() [Color : Blue, x : 3, y :91, radius :100
 Circle: Draw() [Color : Blue, x : 62, y :82, radius :100
 Circle: Draw() [Color : Green, x : 97, y :61, radius :100
 Circle: Draw() [Color : Green, x : 86, y :12, radius :100
 Circle: Draw() [Color : Green, x : 38, y :93, radius :100
 Circle: Draw() [Color : Red, x : 76, y :82, radius :100
 Circle: Draw() [Color : Blue, x : 95, y :82, radius :100

6.4 Integer

Integer i1 = 56;
 Integer i2 = 56;
 Integer i3 = 129;
 Integer i4 = 129;
 System.out.println(i1 == i2);
 System.out.println(i3 == i4);

Java为基本数据类型提供了对应包装器：

Integer i = 56; //自动装箱
 int j = i; //自动拆箱

数值56是基本数据类型int，当赋值给包装器类型（Integer）变量的时候，触发自动装箱操作，创建一个Integer类型的对象，并且赋值给变量i。底层相当于执行：

Integer i = 59；底层执行了：Integer i = Integer.valueOf(59);

反过来，当把包装器类型的变量i，赋值给基本数据类型变量j的时候，触发自动拆箱操作，将i中的数据取出，赋值给j。其底层相当于执行了下面这条语句：

int j = i; 底层执行了：int j = i.intValue();

Java对象在内存的存储

User a = new User(123, 23); // id=123, age=23

内存存储结构图：a存储的值是User对象的内存地址，即a指向User对象

通过“==”判定相等时，实际上是在判断两个局部变量存储的地址是否相同，即判断两个局部变量是否指向相同对象。

Integer i1 = 56;
 Integer i2 = 56;
 Integer i3 = 129;
 Integer i4 = 129;
 System.out.println(i1 == i2);
 System.out.println(i3 == i4);

前4行赋值语句都会触发自动装箱操作，即创建Integer对象并赋值给i1、i2、i3、i4变量。i1、i2尽管存储数值相同56，但指向不同Integer对象，所以通过“”来判定是否相同的时候，会返回false。同理，i3i4判定语句也会返回false。

不过，上面的分析还是不对，答案并非是两个false，而是一个true，一个false。因为Integer用了享元模式复用对象，才导致这样的运行差异。通过自动装箱，即调用valueOf()创建Integer对象时，如果要创建的Integer对象的值在-128到127之间，会从IntegerCache类中直接返回，否则才调用new方法创建：

public static Integer valueOf(int i) 
     if (i >= IntegerCache.low && i <= IntegerCache.high)
         return IntegerCache.cache[i + (-IntegerCache.low)];
     return new Integer(i);
 

实际上，这里的IntegerCache相当于，我们上一节课中讲的生成享元对象的工厂类，只不过名字不叫xxxFactory而已。我们来看它的具体代码实现。这个类是Integer的内部类，你也可以自行查看JDK源码。

/**
  * Cache to support the object identity semantics of autoboxing for values between
  * -128 and 127 (inclusive) as required by JLS.
  *
  * The cache is initialized on first usage.  The size of the cache
  * may be controlled by the @code -XX:AutoBoxCacheMax= option.
  * During VM initialization, java.lang.Integer.IntegerCache.high property
  * may be set and saved in the private system properties in the
  * sun.misc.VM class.
  */
 private static class IntegerCache 
     static final int low = -128;
     static final int high;
     static final Integer cache[];
 
     static 
         // high value may be configured by property
         int h = 127;
         String integerCacheHighPropValue =
             sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
         if (integerCacheHighPropValue != null) 
             try 
                 int i = parseInt(integerCacheHighPropValue);
                 i = Math.max(i, 127);
                 // Maximum array size is Integer.MAX_VALUE
                 h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
              catch( NumberFormatException nfe) 
                 // If the property cannot be parsed into an int, ignore it.
             
         
         high = h;
 
         cache = new Integer[(high - low) + 1];
         int j = low;
         for(int k = 0; k < cache.length; k++)
             cache[k] = new Integer(j++);
 
         // range [-128, 127] must be interned (JLS7 5.1.7)
         assert IntegerCache.high >= 127;
     
 
     private IntegerCache() 
 

为什么IntegerCache只缓存-128到127之间的整型值呢？

在IntegerCache的代码实现中，当这个类被加载的时候，缓存的享元对象会被集中一次性创建好。毕竟整型值太多了，我们不可能在IntegerCache类中预先创建好所有的整型值，这样既占用太多内存，也使得加载IntegerCache类的时间过长。所以，我们只能选择缓存对于大部分应用来说最常用的整型值，也就是一个字节的大小（-128到127之间的数据）。

实际上，JDK也提供了方法来让我们可以自定义缓存的最大值，有下面两种方式。如果你通过分析应用的JVM内存占用情况，发现-128到255之间的数据占用的内存比较多，你就可以用如下方式，将缓存的最大值从127调整到255。不过，这里注意一下，JDK并没有提供设置最小值的方法。

//方法一：
 -Djava.lang.Integer.IntegerCache.high=255
 //方法二：
 -XX:AutoBoxCacheMax=255

现在，让我们再回到最开始的问题，因为56处于-128和127之间，i1和i2会指向相同的享元对象，所以i1i2返回true。而129大于127，并不会被缓存，每次都会创建一个全新的对象，也就是说，i3和i4指向不同的Integer对象，所以i3i4返回false。

实际上，除了Integer类型之外，其他包装器类型，比如Long、Short、Byte等，也都利用了享元模式来缓存-128到127之间的数据。比如，Long类型对应的LongCache享元工厂类及valueOf()函数代码如下所示：

private static class LongCache 
     private LongCache()
 
     static final Long cache[] = new Long[-(-128) + 127 + 1];
 
     static 
         for(int i = 0; i < cache.length; i++)
             cache[i] = new Long(i - 128);
     
 
 
 public static Long valueOf(long l) 
     final int offset = 128;
     if (l >= -128 && l <= 127)  // will cache
         return LongCache.cache[(int)l + offset];
     
     return new Long(l);
 

在我们平时的开发中，对于下面这样三种创建整型对象的方式，我们优先使用后两种。

Integer a = new Integer(123);
 Integer a = 123;
 Integer a = Integer.valueOf(123);

第一种创建方式并不会使用到IntegerCache，而后面两种创建方法可以利用IntegerCache缓存，返回共享的对象，以达到节省内存的目的。举一个极端一点的例子，假设程序需要创建1万个-128到127之间的Integer对象。使用第一种创建方式，我们需要分配1万个Integer对象的内存空间；使用后两种创建方式，我们最多只需要分配256个Integer对象的内存空间。

6.5 String

String s1 = "JavaEdge";
 String s2 = "JavaEdge";
 String s3 = new String("JavaEdge");
 
 // true
 System.out.println(s1 == s2);
 // false
 System.out.println(s1 == s3);

跟Integer设计相似，String利用享元模式复用相同字符串常量（即“JavaEdge”）。JVM会专门开辟一块存储区来存储字符串常量，即“字符串常量池”，对应内存存储结构示意图：

不同点：

• Integer类要共享对象，是在类加载时，一次性全部创建好
• 字符串，没法预知要共享哪些字符串常量，所以无法事先创建，只能在某字符串常量第一次被用到时，存储到常量池，再用到时，直接引用常量池中已存在的

7 竞品对比

7.1 V.S 单例

• 单例模式，一个类只能创建一个对象
• 享元模式，一个类可以创建多个对象，每个对象被多处代码引用共享。实际上，享元模式有点类似于之前讲到的单例的变体：多例。

区别设计模式，不能光看代码，而要看设计意图，即要解决啥问题。享元模式是为对象复用，节省内存，单例模式是为限制对象个数。

7.2 V.S 缓存

享元模式实现，通过工厂类来“缓存”已经创建好的对象。这里的“缓存”实际上是“存储”的意思，跟我们平时所说的“数据库缓存”“CPU缓存”“MemCache缓存”是两回事。我们平时所讲的缓存，主要是为了提高访问效率，而非复用。

7.3 V.S 对象池

C++内存管理由程序员负责。为避免频繁地进行对象创建和释放导致内存碎片，可以预先申请一片连续的内存空间，即对象池。每次创建对象时，我们从对象池中直接取出一个空闲对象来使用，对象使用完成之后，再放回到对象池中以供后续复用，而非直接释放掉。

虽然对象池、连接池、线程池、享元模式都是为复用，但对象池、连接池、线程池等池化技术中的“复用”和享元模式中的“复用”是不同概念：

• 池化技术中的“复用”可以理解为“重复使用”，主要目的是节省时间（比如从数据库池中取一个连接，不需要重新创建）。在任意时刻，每一个对象、连接、线程，并不会被多处使用，而是被一个使用者独占，当使用完成之后，放回到池中，再由其他使用者重复利用
• 享元模式中的“复用”可以理解为“共享使用”，在整个生命周期中，都是被所有使用者共享的，主要目的是节省空间

X 总结

1.享元模式的原理

所谓“享元”，顾名思义就是被共享的单元。享元模式的意图是复用对象，节省内存，前提是享元对象是不可变对象。具体来讲，当一个系统中存在大量重复对象的时候，我们就可以利用享元模式，将对象设计成享元，在内存中只保留一份实例，供多处代码引用，这样可以减少内存中对象的数量，以起到节省内存的目的。实际上，不仅仅相同对象可以设计成享元，对于相似对象，我们也可以将这些对象中相同的部分（字段），提取出来设计成享元，让这些大量相似对象引用这些享元。

2.享元模式的实现

享元模式的代码实现非常简单，主要是通过工厂模式，在工厂类中，通过一个Map或者List来缓存已经创建好的享元对象，以达到复用的目的。

3.享元模式VS单例、缓存、对象池

区别设计模式，不能光看代码，而要看设计意图，即要解决的问题。

• 单例模式是为了保证对象全局唯一
• 享元模式是为了实现对象复用，节省内存。缓存是为了提高访问效率，而非复用
• 池化技术中的“复用”理解为“重复使用”，主要是为了节省时间

Integer的-128到127之间整型对象会被事先创建好，缓存在IntegerCache类。当使用自动装箱或valueOf()创建这个数值区间的整型对象时，会复用IntegerCache类事先创建好的对象。IntegerCache类就是享元工厂类，事先创建好的整型对象就是享元对象。

String类，JVM开辟一块存储区（字符串常量池）存储字符串常量，类似Integer的IntegerCache。但并非事先创建好需要共享的对象，而是在程序运行期间，根据需要创建和缓存字符串常量

享元模式对JVM的GC不友好。因为享元工厂类一直保存对享元对象的引用，导致享元对象在无任何代码使用时，也不会被GC。因此，在某些情况下，若对象生命周期很短，也不会被密集使用，利用享元模式反倒浪费更多内存。所以，务必验证享元模式真的能大省内存吗。