Java 设计模式(18) —— 蝇量模式

一、蝇量模式

通过共享的方式高效地支持大量细粒度的对象。

蝇量模式

二、示例

景观设计软件项目：现在有一个设计景观展示的项目，项目内部已经有的对象有树，树的属性有年龄，x、y的坐标。现在要表示成一个森林，则需要通过大量的树模拟成森林

每一颗树的属性和方法都是相同的，只是值不同

传统方法就是定义大量的树对象，当成森林使用时则循环遍历每一颗树的内部方法就行。

/**
 * 传统模式，树的对象，包含树的x,y坐标和年龄
 */
public class Tree {
    private int xCoord, yCoord, age;

    public Tree(int xCoord, int yCoord, int age) {
        this.xCoord = xCoord;
        this.yCoord = yCoord;
        this.age = age;
    }

    public void display() {
        // System.out.print("x");
    }
}

/**
 * 测试传统模式，一个对象一个类，用到时循环遍历
 */
public class TreesTest {

    private int length = 10000000;
    private Tree[] treelst = new Tree[length];

    public TreesTest() {
        for (int i = 0; i < length; i++) {
            treelst[i] = new Tree((int) (Math.random() * length),
                    (int) (Math.random() * length),
                    (int) (Math.random() * length) % 5);
        }
    }

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

}

/**
 * 传统模式，将树定义成单个对象，模拟森林时则直接通过遍历遍历一个个的对象，占用内存较大，耗时较长
 */
public class MainTest {

    public static void main(String[] args) {
        showMemInfo();
        TreesTest mTreesTest;
        mTreesTest = new TreesTest();

        showMemInfo();
        mTreesTest.display();
        showMemInfo();
    }

    public static void showMemInfo() {
        // 最大内存：
        long max = Runtime.getRuntime().maxMemory();
        // 分配内存：
        long total = Runtime.getRuntime().totalMemory();
        // 已分配内存中的剩余空间 ：
        long free = Runtime.getRuntime().freeMemory();
        // 已占用的内存：
        long used = total - free;

        System.out.println("最大内存 = " + max);
        System.out.println("已分配内存 = " + total);
        System.out.println("已分配内存中的剩余空间 = " + free);
        System.out.println("已用内存 = " + used);
        System.out.println("时间 = " + System.currentTimeMillis());
        System.out.println();

    }

}

虽然这种方式也可以实现需求，但是由于树的对象数量较大，则运行时占用内存更高，耗时较长

三、蝇量模式

由于每一个树对象的属性和方法都是相同的，只是属性的值不同。则可以蝇量模式，定义一个树的管理者对象，内部定义多个集合来存储所有树的单个属性，则当成森林调用时只用调用这个管理者对象即可

/**
 * 蝇量模式，重新定义一个对象模拟森林，在对象内部用集合重新定义多个树对象的属性
 */
public class TreeManager {

    private int length = 10000000;
    int[] xArray = new int[length], yArray = new int[length],
            AgeArray = new int[length];

    private TreeFlyWeight mTreeFlyWeight;

    public TreeManager() {

        mTreeFlyWeight = new TreeFlyWeight();
        for (int i = 0; i < length; i++) {

            xArray[i] = (int) (Math.random() * length);
            yArray[i] = (int) (Math.random() * length);
            AgeArray[i] = (int) (Math.random() * length) % 5;

        }

    }

    public void displayTrees() {

        for (int i = 0; i < length; i++) {
            mTreeFlyWeight.display(xArray[i], yArray[i], AgeArray[i]);
        }
    }

}

/**
 * 蝇量模式，定义新的对象将树对象的各属性内部定义成集合，则调用时只用调用这一个对象即可
 * 占用内存更少，耗时更短
 */
public class MainTest {

    public static void main(String[] args) {

        showMemInfo();

        TreeManager mTreeManager;
        mTreeManager = new TreeManager();

        showMemInfo();
        mTreeManager.displayTrees();
        showMemInfo();

    }

    public static void showMemInfo() {
        // 已分配内存中的剩余空间 ：
        long free = Runtime.getRuntime().freeMemory();
        // 分配内存：
        long total = Runtime.getRuntime().totalMemory();
        // 最大内存：
        long max = Runtime.getRuntime().maxMemory();
        // 已占用的内存：

        long used = total - free;

        System.out.println("最大内存 = " + max);
        System.out.println("已分配内存 = " + total);
        System.out.println("已分配内存中的剩余空间 = " + free);
        System.out.println("已用内存 = " + used);
        System.out.println("时间 = " + System.currentTimeMillis());
        System.out.println();
    }

}

四、总结

1. 优点：

   • 减少运行时的对象实例个数，节省创建开销和内存
   • 将许多“虚拟”对象的状态集中管理

2. 缺点：

   • 系统设计更加复杂
   • 需要专门维护对象的外部状态

3. 适用场合：

   • 需要大量细粒度对象
   • 这些对象的外部状态不多
   • 按照内部状态分成几个组，每一个组都仅用一个蝇量对象代替

Java设计模式所有示例代码，持续更新中