一、蝇量模式
通过共享的方式高效地支持大量细粒度的对象。
蝇量模式
二、示例
景观设计软件项目：现在有一个设计景观展示的项目，项目内部已经有的对象有树，树的属性有年龄，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();
}
}
四、总结
-
优点：
- 减少运行时的对象实例个数，节省创建开销和内存
- 将许多“虚拟”对象的状态集中管理
-
缺点：
- 系统设计更加复杂
- 需要专门维护对象的外部状态
-
适用场合：
- 需要大量细粒度对象
- 这些对象的外部状态不多
- 按照内部状态分成几个组，每一个组都仅用一个蝇量对象代替
Java设计模式所有示例代码，持续更新中
