14，享元模式

14.1 享元模式的定义和特点

享元（Flyweight）模式的定义：使用共享技术来无效地反对大量细粒度对象的复用,它通过共享曾经存在的对象来大幅度缩小须要创立的对象数量、防止大量类似类的开销，从而进步系统资源的利用率。

享元模式的次要长处是：雷同对象只有保留一份，这升高了零碎中对象的数量，从而升高了零碎中细粒度对象给内存带来的压力。

其次要毛病是：

为了使对象能够共享，须要将一些不能共享的状态内部化，这将减少程序的复杂性。
读取享元模式的内部状态会使得运行工夫略微变长。

14.2 享元模式的构造与实现

14.2.1 享元模式的构造

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

外部状态，即不会随着环境的扭转而扭转的可共享局部。
内部状态，指随环境扭转而扭转的不能够共享的局部。享元模式的实现要领就是辨别利用中的这两种状态，并将内部状态内部化。

享元模式的次要有以下角色：

形象享元角色（Flyweight）：通常是一个接口或抽象类，在形象享元类中申明了具体享元类公共的办法，这些办法能够向外界提供享元对象的外部数据（外部状态），同时也能够通过这些办法来设置内部数据（内部状态）。
具体享元（Concrete Flyweight）角色：它实现了形象享元类，称为享元对象；在具体享元类中为外部状态提供了存储空间。通常咱们能够联合单例模式来设计具体享元类，为每一个具体享元类提供惟一的享元对象。
非享元（Unsharable Flyweight)角色：并不是所有的形象享元类的子类都须要被共享，不能被共享的子类可设计为非共享具体享元类；当须要一个非共享具体享元类的对象时能够间接通过实例化创立。
享元工厂（Flyweight Factory）角色：负责创立和治理享元角色。当客户对象申请一个享元对象时，享元工厂检査零碎中是否存在符合要求的享元对象，如果存在则提供给客户；如果不存在的话，则创立一个新的享元对象。

14.2.1代码实现

关系类图

IBox 定义不同的形态

package com.zhuang.flyweight;/** * @Classname IBox * @Description I图形类(具体享元角色) * @Date 2021/3/25 15:33 * @Created by dell */public class IBox extends AbstractBox {    @Override    public String getShape() {        return "I";    }}

LBox 定义不同的形态

package com.zhuang.flyweight;/** * @Classname IBox * @Description L图形类(具体享元角色) * @Date 2021/3/25 15:33 * @Created by dell */public class LBox extends AbstractBox {    @Override    public String getShape() {        return "L";    }}

OBox 定义不同的形态

package com.zhuang.flyweight;/** * @Classname IBox * @Description O图形类(具体享元角色) * @Date 2021/3/25 15:33 * @Created by dell */public class OBox extends AbstractBox {    @Override    public String getShape() {        return "O";    }}

BoxFactory 提供了一个工厂类（BoxFactory），用来治理享元对象（也就是AbstractBox子类对象），该工厂类对象只须要一个，所以能够应用单例模式。并给工厂类提供一个获取形态的办法

package com.zhuang.flyweight;import java.util.HashMap;/** * @Classname BoxFactory * @Description 工厂类 将类设计为单例模式 * @Date 2021/3/25 15:33 * @Created by dell */public class BoxFactory {    private HashMap<String, AbstractBox> map;    //在构造方法中初始化    private BoxFactory() {        map = new HashMap<String, AbstractBox>();        IBox iBox = new IBox();        LBox lBox = new LBox();        OBox oBox = new OBox();        map.put("I", iBox);        map.put("L", lBox);        map.put("O", oBox);    }    //申明一个办法获取工厂    public static BoxFactory getInstance() {        return SingletonHolder.INSTANCE;    }    private static class SingletonHolder {        private static final BoxFactory INSTANCE = new BoxFactory();    }    //依据图形名称获取图形对象    public AbstractBox getShape(String name) {        return map.get(name);    }}

AbstractBox 对这些形态向上抽取出AbstractBox，用来定义共性的属性和行为

package com.zhuang.flyweight;/** * @Classname AbstractBox * @Description 形象享元角色 抽象类 * @Date 2021/3/25 15:32 * @Created by dell */public abstract class AbstractBox {    //获取图形的办法    public abstract String getShape();    //显示图形及色彩    public void display(String color) {        System.out.println("方块形态：" + this.getShape() + "色彩：" + color);    }}

14.3 享元模式的利用场景

当零碎中多处须要同一组信息时，能够把这些信息封装到一个对象中，而后对该对象进行缓存，这样，一个对象就能够提供给多出须要应用的中央，防止大量同一对象的屡次创立，升高大量内存空间的耗费。

享元模式其实是工厂办法模式的一个改良机制，享元模式同样要求创立一个或一组对象，并且就是通过工厂办法模式生成对象的，只不过享元模式为工厂办法模式减少了缓存这一性能。

后面剖析了享元模式的构造与特点，上面剖析它实用的利用场景。享元模式是通过缩小内存中对象的数量来节俭内存空间的，所以以下几种情景适宜采纳享元模式。

零碎中存在大量雷同或类似的对象，这些对象消耗大量的内存资源。
大部分的对象能够依照外部状态进行分组，且可将不同局部内部化，这样每一个组只需保留一个外部状态。
因为享元模式须要额定保护一个保留享元的数据结构，所以该当在有足够多的享元实例时才值得应用享元模式

14.4 JDK源码解析

Integer类应用了享元模式。咱们先看上面的例子：

public class Demo {    public static void main(String[] args) {        Integer i1 = 127;        Integer i2 = 127;        System.out.println("i1和i2对象是否是同一个对象？" + (i1 == i2));        Integer i3 = 128;        Integer i4 = 128;        System.out.println("i3和i4对象是否是同一个对象？" + (i3 == i4));    }}

后果是 true false

为什么第一个输入语句输入的是true，第二个输入语句输入的是false？通过反编译软件进行反编译，代码如下：

public class Demo {    public static void main(String[] args) {        Integer i1 = Integer.valueOf((int)127);        Integer i2 Integer.valueOf((int)127);        System.out.println((String)new StringBuilder().append((String)"i1\u548ci2\u5bf9\u8c61\u662f\u5426\u662f\u540c\u4e00\u4e2a\u5bf9\u8c61\uff1f").append((boolean)(i1 == i2)).toString());        Integer i3 = Integer.valueOf((int)128);        Integer i4 = Integer.valueOf((int)128);        System.out.println((String)new StringBuilder().append((String)"i3\u548ci4\u5bf9\u8c61\u662f\u5426\u662f\u540c\u4e00\u4e2a\u5bf9\u8c61\uff1f").append((boolean)(i3 == i4)).toString());    }}

下面代码能够看到，间接给Integer类型的变量赋值根本数据类型数据的操作底层应用的是 valueOf() ，所以只须要看该办法即可

public final class Integer extends Number implements Comparable<Integer> {        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 {            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) {                }            }            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 默认先创立并缓存 -128 ~ 127 之间数的 Integer 对象，当调用 valueOf 时如果参数在 -128 ~ 127 之间则计算下标并从缓存中返回，否则创立一个新的 Integer 对象。

写在最初

如果我的文章对你有用，请给我点个，感激你！
有问题，欢送在评论区指出！