设计模式之享元模式

Flyweight design pattern

享元模式的概念、享元模式的结构、享元模式的优缺点、享元模式的使用场景、享元模式的实现示例、享元模式的源码分析

---

1、享元模式的概念

  享元模式，即运用共享技术来有效的支持大量细粒度对象的复用。它通过共享已经存在的对象来大幅度减少需要创建的对象数量，避免大量相似对象的开销，从而提高系统资源的利用率。

  享元模式中存在以下两种状态：

• 内部状态：即不会随着环境的改变而改变的可共享状态。
• 外部状态：即随着环境的改变而改变的不可共享状态。享元模式的实现要领就是区分应用中的这两种状态，并将外部状态外部化。

2、享元模式的结构

• 抽象享元角色：定义向外界提供内部状态的抽象方法，同时声明外界设置外部状态的的方法。
• 具体享元角色：继承自抽象享元角色，实现向外界提供内部状态的抽象方法。
• 飞享元角色：即外部状态，即不可共享的部分，可以参数的形式注入到享元对象中去。
• 享元工厂：负责创建和管理享元对象。当客户对象请求一个享元对象时，享元工厂检查系统中是否已存在符合要求的享元对象，若存在则返回给用户，若不存在则创建一个新的享元对象返回给客户并维护到系统中。因为系统中享元角色的创建和管理只需一个角色，故此工厂可设计位单例。

3、享元模式的优缺点

• 优点：
  • 减少相似对象的创建，降低系统内存开销，提高效率。
• 缺点：
  • 一定程度上增加了系统的复杂度，需要分离出内部状态和外部状态，内部状态不变，外部状态可变，容易造成系统混乱。

4、享元模式的使用场景

• 当系统中存在大量相同或相似的对象时，避免造成系统内存大量耗费。
• 当对象的大部分状态可外部化时，可将这些外部状态传入对象中。
• 在使用享元模式时，需要维护一个存储享元对象的享元池，而这需要耗费一定的系统资源，故，应在需要多次重复使用享元对象时才值得使用享元模式。

5、享元模式的实现示例

抽象享元角色：

public abstract class Hero {

    /**
     * 向外界提供不可变内部状态（可共享）
     * @return
     */
    public abstract String getName();

    /**
     * 外界设置可变外部状态（不可共享）
     * @param equipment
     */
    public void equipment(String equipment) {
        System.out.println("英雄名称 " + this.getName() + " 装备 " + equipment);
    }
}

具体享元角色：

public class ZedHero extends Hero {

    @Override
    public String getName() {
        return "影流之主";
    }
}

具体享元角色：

public class FizzHero extends Hero {

    @Override
    public String getName() {
        return "潮汐海灵";
    }
}

具体享元角色：

public class AhriHero extends Hero {

    @Override
    public String getName() {
        return "九尾妖狐";
    }
}

享元工厂：

public class FlyWeightFactory {

    private static Map<String, Hero> map;

    private static FlyWeightFactory factory;

    private FlyWeightFactory() {
        map = new HashMap<>(3);
        map.put("zed", new ZedHero());
        map.put("fizz", new FizzHero());
        map.put("ahri", new AhriHero());
    }

    public static FlyWeightFactory getInstance() {
        if (factory == null) {
            synchronized (FlyWeightFactory.class) {
                if (factory == null) {
                    factory = new FlyWeightFactory();
                }
            }
        }
        return factory;
    }

    public Hero getHero(String name) {
        return map.get(name);
    }
}

测试：

public class FlyWeightTest {

    public static void main(String[] args) {
        Hero zed = FlyWeightFactory.getInstance().getHero("zed");
        zed.equipment("德拉克撒的慕刃");

        Hero fizz = FlyWeightFactory.getInstance().getHero("fizz");
        fizz.equipment("卢登的激荡");

        Hero zed1 = FlyWeightFactory.getInstance().getHero("zed");
        zed1.equipment("赛瑞尔达的怨恨");

        System.out.println(zed == zed1);
    }
}

测试结果：

英雄名称 影流之主 装备 德拉克撒的慕刃
英雄名称 潮汐海灵 装备 卢登的激荡
英雄名称 影流之主 装备 赛瑞尔达的怨恨
true

6、享元模式的源码分析

  jdk 的 Integer 类的设计就使用到了享元模式。

public class IntegerTest {

    public static void main(String[] args) {
        Integer a = 127;
        Integer b = 127;

        Integer c = 128;
        Integer d = 128;

        System.out.println(a == b);
        System.out.println(c == d);
    }
}

// 测试结果
true
false

  从测试结果结合 Integer 源码可知，Integer 对 -128 ~ 127 之间的数进行了缓存，所以对象 a、b 实际上是同一个对象，因为其被换存在内存中了，而对象 c、d 则是两个不同的对象，因为其没有被缓存。

  Integer a = 127; 这段代码反编译后实际上会变成 Integer a = Integer.valueOf((int) 127); 也就是实际上是调用了 Integer 的 valueOf() 方法。

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

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 =
      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() {}
}

  从 Integer.valueOf() 的源码可知，Integer 内部用了一个 IntegerCache 内部类来维护要被缓存的数值范围即被缓存的对象数组，可以看到在 low（-128） 到 high（127）之间的数值被缓存在 cache[] 中了。在调用 Integer.valueOf() 方法时，如果传入的值在 low 和 high 之间，则之间返回数组中的元素，若不在则创建一个新的对象返回。