享元（轻量级）模式

简介

享元模式（Flyweight Pattern）又叫作轻量级模式，是对象池的一种实现。类似线程池，线程池可以避免不停地创建和销毁多个对象，消耗性能。享元模式提供了减少对象数量从而改善应用所需的对象结构的方式。其宗旨是共享细粒度对象，将多个对同一对象的访问集中起来，不必为每个访问者都创建一个单独的对象，以此来降低内存的消耗，属于结构型设计模式。

享元（Flyweight）的核心思想很简单：如果一个对象实例一经创建就不可变，那么反复创建相同的实例就没有必要，直接向调用方返回一个共享的实例就行，这样即节省内存，又可以减少创建对象的过程，提高运行速度。

通用模板

1. 创建抽象享元角色：享元对象抽象基类或者接口。

   
   // 享元接口
   public interface IFlyweight {
       void operation(String extrinsicState);
   }
   

2. 创建具体享元角色：实现抽象角色定义的业务。

   
   // 具体的享元角色
   public class FlyWeight implements IFlyweight {
       private String intrinsicState;
   
       public FlyWeight(String intrinsicState) {
           this.intrinsicState = intrinsicState;
       }
   
       @Override
       public void operation(String extrinsicState) {
           System.out.println("Object address: " + System.identityHashCode(this));
           System.out.println("IntrinsicState: " + this.intrinsicState);
           System.out.println("ExtrinsicState: " + extrinsicState);
       }
   }
   

3. 创建享元工厂：：负责管理享元对象池和创建享元对象。

   import java.util.HashMap;
   import java.util.Map;
   // 享元工厂
   public class FlyweightFactory {
       private static Map<String, IFlyweight> pool = new HashMap<String, IFlyweight>();
   
       // 因为内部状态具备不变性，因此作为缓存的键
       public static IFlyweight getFlyweight(String intrinsicState) {
           if (!pool.containsKey(intrinsicState)) {
               IFlyweight flyweight = new FlyWeight(intrinsicState);
               pool.put(intrinsicState, flyweight);
           }
           return pool.get(intrinsicState);
       }
   }
   

模板测试

1. 代码

   public class Client {
       public static void main(String[] args) {
           IFlyweight flyweight1 = FlyweightFactory.getFlyweight("aa");
           IFlyweight flyweight2 = FlyweightFactory.getFlyweight("aa");
           flyweight1.operation("aa");
           flyweight2.operation("b");
       }
   }
   

2. 结果

   Object address: 2133927002
   IntrinsicState: aa
   ExtrinsicState: aa
   Object address: 2133927002
   IntrinsicState: aa
   ExtrinsicState: b
   

内部状态和外部状态

享元模式的定义提出了两个要求：细粒度和共享对象。因为要求细粒度，所以不可避免地会使对象数量多且性质相近，此时我们就将这些对象的信息分为两个部分：内部状态和外部状态。
内部状态指对象共享出来的信息，存储在享元对象内部，并且不会随环境的改变而改变；外部状态指对象得以依赖的一个标记，随环境的改变而改变，不可共享。
比如，连接池中的连接对象，保存在连接对象中的用户名、密码、连接URL等信息，在创建对象的时候就设置好了，不会随环境的改变而改变，这些为内部状态。而当每个连接要被回收利用时，我们需要将它标记为可用状态，这些为外部状态。

应用场景

在生活中，享元模式非常常见，比如各中介机构的房源共享，再比如全国社保联网。 当系统中多处需要同一组信息时，可以把这些信息封装到一个对象中，然后对该对象进行缓存，这样，一个对象就可以提供给多处需要使用的地方，避免大量同一对象的多次创建，降低大量内存空间的消耗。 享元模式其实是工厂方法模式的一个改进机制，享元模式同样要求创建一个或一组对象，并且就是通过工厂方法模式生成对象的，只不过享元模式为工厂方法模式增加了缓存这一功能。主要应用场景如下。 （1）常应用于系统底层的开发，以便解决系统的性能问题。
（2）系统有大量相似对象、需要缓冲池的场景。

优点

（1）减少对象的创建，降低内存中对象的数量，降低系统的内存，提高效率。
（2）减少内存之外的其他资源占用。

缺点

（1）关注内、外部状态，关注线程安全问题。
（2）使系统、程序的逻辑复杂化。

“生搬硬套”实战

场景描述

一个典型的享元模式的应用场景是在处理大量细粒度对象时，比如在一个文字处理软件中表示文档中的字符。如果每个字符都作为一个独立的对象创建，那么对于一个包含数千字符的文档来说，将会有大量的对象被创建，这会消耗大量的内存。使用享元模式可以有效地减少内存使用，因为相同的字符可以被多个位置共享。

代码开发

根据模板我们知道抽象工厂和工厂方法模式一样也是拢共就是3步：

1. 创建抽象享元角色（这里指的是字符享元接口）

   // 字符享元接口
   public interface ICharFlyweight {
       // 展示字符位置的方法
       void display(int position);
   }
   

2. 创建具体享元角色（这里指的是字符对象的具体类）

   // 具体的字符享元实现
   public class ConcreteCharFlyweight implements ICharFlyweight {
       private final char character;
   
       public ConcreteCharFlyweight(char character) {
           this.character = character;
       }
   
       @Override
       public void display(int position) {
           System.out.println("Displaying '" + character + "' at position " + position);
       }
   }
   

3. 创建享元工厂（这里指的是创建字符对象的工厂）

   // 创建字符对象的工厂，如果字符对象已经存在，则直接使用，否则存储起来备用
   public class FlyweightFactory {
       private static final Map<Character, ICharFlyweight> pool = new HashMap<Character, ICharFlyweight>();
   
       public static ICharFlyweight getCharFlyweight(char character) {
           ICharFlyweight flyweight = pool.get(character);
           if (flyweight == null) {
               flyweight = new ConcreteCharFlyweight(character);
               pool.put(character, flyweight);
           }
           return flyweight;
       }
   }
   

至此，我们就通过“生搬硬套”享元模式的模板设计出一套对象池开发流程，接下来我们进行测试：

• 测试代码

  public class Demo {
      public static void main(String[] args) {
          String text = "Hello World!";
          for (int i = 0; i < text.length(); i++) {
              char c = text.charAt(i);
              ICharFlyweight flyweight = FlyweightFactory.getCharFlyweight(c);
              flyweight.display(i);
          }
      }
  }
  

• 结果

  Displaying 'H' at position 0
  Displaying 'e' at position 1
  Displaying 'l' at position 2
  Displaying 'l' at position 3
  Displaying 'o' at position 4
  Displaying ' ' at position 5
  Displaying 'W' at position 6
  Displaying 'o' at position 7
  Displaying 'r' at position 8
  Displaying 'l' at position 9
  Displaying 'd' at position 10
  Displaying '!' at position 11
  

这样每当有已经出现过的字符出现，则复用对象。

总结

享元模式的本质是缓存共享对象，降低内存消耗。