设计模式之享元模式

1. 享元模式定义

  享元模式(FlyWeight): 当需要某个实例时，并不总是通过new来创建，尽量使用已存在的实例，以达到节省内存的目的。

2. 程序示例

  假设需要在控制台显示0~2范围的大数字(右多行多列#.组成的数字)，每个大字符由一个txt文件保存，命名为0.txt, 1.txt, 2.txt ,如下图所示:

        

  一个大字符对应一个BigChar类：

public class BigChar {

    private String fontData;

    public BigChar(String name) {

        try {
            StringBuffer buf = new StringBuffer();
            Reader reader = new FileReader(System.getProperty("user.dir") + "/src/main/resources/flyweight/" + name + ".txt");

            BufferedReader bfr = new BufferedReader(reader);

            String line;
            while (null != (line = bfr.readLine())) {
                buf.append(line).append("\n");
            }

            fontData = buf.toString();

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    public void display() {
        System.out.println(fontData);
    }

}

  接下来定义一个大字符的工厂类BigCharFactory，用于获取大字符对象：

    public class BigCharFactory {


    private volatile Map<String, BigChar> pool = new HashMap<>();

    static class InstanceHolder {
        static BigCharFactory instance = new BigCharFactory();
    }

    public static BigCharFactory getInstance() {
        return InstanceHolder.instance;
    }

    /**
     * get BigChar from pool
     *
     * @param charName
     * @return
     */
    public BigChar getChar(String charName) {

        BigChar bigChar = pool.get(charName);

        if (null == bigChar) {
            synchronized (BigCharFactory.class) {
                bigChar = pool.get(charName);
                if (null == bigChar) {
                    bigChar = new BigChar(charName);
                    pool.put(charName, bigChar);
                }
            }
        }

        return bigChar;

    }
}

  现在当需要展示一连串字符012012012…012时，可以定义一个类BigString去接收参数并展示大字符对象：

public class BigString {

    private BigChar[] bigChars;

    /**
     *
     * @param chars 要展示的大字符串
     * @param shared
     */
    public BigString(String chars, boolean shared) {

        int len = chars.length();
        bigChars = new BigChar[len];

        for (int i = 0; i < len; i++) {
            char ch = chars.charAt(i);
            String s = String.valueOf(ch);

            bigChars[i] = shared ? getCharShared(s) : getCharWithNoShared(s);
        }
    }

    /**
     * 以非共享的方式获取一个大字符对象
     * @param s
     * @return
     */
    private BigChar getCharWithNoShared(String s) {
        return new BigChar(s);
    }

    /***
     * 以共享的方式获取一个大字符对象
     * @param s
     * @return
     */
    private BigChar getCharShared(String s) {
        BigCharFactory factory = BigCharFactory.getInstance();
        return factory.getChar(String.valueOf(s));
    }

    public void display() {
        for(int i = 0; i < bigChars.length; i++) {
            bigChars[i].display();
        }
    }
}

是时候创建一个Main去调用一把了:

public class Main{

    public static void main(String[] args) {

        Runtime.getRuntime().gc();
        BigString bs = new BigString("120120120120120120120120120120120120120120120120120120120120120120120120", true);
        bs.display();

    }
}

整个调用过程结束。原理很简单，尽管一个数字代表一个BigChar对象，但是他们可以共用一个对象，这样很长的一个字符串也就只创建了3个BigChar对象而已，实现的核心是BigCharFactory.getChar()方法。

其实还可以在原来的Client加点代码，看看使用共享对象与不使用共享对象，实现相同的功能，内存使用量的差异。

Runtime.getRuntime().gc();
        BigString bs1 = new BigString("120120120120120120120120120120120120120120120120120120120120120120120120", true); //true,false分别对比
        long used1 = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();

        System.out.println("shared:" + used1);

3. 类图结构

  这里的类图和上面的例子对应，和GOF设计模式的图有些区别。

  角色划分：

• FlyWeight: 对应BigChar类

• FlyWeightFactory:对应BigCharFactory类

• Client:对应BigString类

4. 注意点

 既然实例是共享的，那么一个地方有改动，势必会影响其他地方，在设计时要仔细权衡那些信息是一定不会变的，哪些是可能会变的， 我们需要将intrinsic信息定义在FlyWeight角色中，而extrinsic 信息则不能定义在Flyweight角色中。

5. 总结

• 优势：减少new关键字生成实例的次数，有效节省内存，提高运行速度。像JDK中 的Integer.valueOf()方法就使用了该模式。

• 不足：感觉会增加系统的复杂性，另外，在设计时需要具体分析intrinsic与extrinsic信息。