2. 程式人生 > >設計模式之享元模式（蠅量模式）

設計模式之享元模式（蠅量模式）

阿新 • • 發佈：2018-11-08

設計模式之享元模式（蠅量模式）

1. 什麼是享元模式

Flyweight模式也叫享元模式，是構造型模式之一，它通過與其他類似物件共享資料來減小記憶體佔用。

換句話說就是通過共享的方式高效地支援大量細粒度的物件。

享元模式的結構：

在這裡插入圖片描述

享元模式的角色和職責：

  • 抽象享元角色：所有具體享元類的父類，規定一些需要實現的公共介面。
  • 具體享元角色：抽象享元角色的具體實現類，並實現了抽象享元角色規定的方法。
  • 享元工廠角色：負責建立和管理享元角色。

優缺點：

優點：

  • 減少執行時的物件例項個數，節省建立開銷和記憶體

  • 將許多“虛擬”物件的狀態集中管理

缺點：

  • 系統設計更加複雜

  • 需要專門維護物件的外部狀態

適用場合：

  • 需要大量細粒度物件

  • 這些物件的外部狀態不多

  • 按照內部狀態分成幾個組，每一個組都僅用一個蠅量物件代替

2. 具體例項

我們有一個景觀設計軟體專案：

需要佈置很多的樹：XY座標，樹的大小，外觀

假如需要10000000棵樹，我們該怎麼設計呢？

首先的想法就是抽象一個樹的類，然後使用的時候初始化10000000個樹的例項。

按照這種方式具體的實現一下：

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("");
	}
}

看一下執行的結果吧

最大記憶體 = 926941184
已分配記憶體 = 64487424
已分配記憶體中的剩餘空間 = 62465304
已用記憶體 = 2022120
時間 = 1539587641214

最大記憶體 = 926941184
已分配記憶體 = 361234432
已分配記憶體中的剩餘空間 = 79750928
已用記憶體 = 281483504
時間 = 1539587644567

最大記憶體 = 926941184
已分配記憶體 = 361234432
已分配記憶體中的剩餘空間 = 79750928
已用記憶體 = 281483504
時間 = 1539587644583

我們這時候發現我們需要多少的樹就要new出多少個樹的物件，佔用記憶體。

看一下樹這個類，他的有些狀態是共享的，如display這個方法，每一個樹的顯示都是一樣的，然後像具體的座標和年齡這個資訊都相當於外部的狀態，每一個都是不同的，我們可以設計一個新的類來管理這些資訊，然後在例項化樹的物件的時候就只需要例項化一個，然後每個樹得資訊從管理類中獲取。那個管理的類中其實就是虛擬化了很多的樹的類。這其實就是享元模式的設計思想，把相似的物件的資料進行共享。

看下具體的實現：

public class TreeFlyWeight {

	public TreeFlyWeight() {
	}

	public void display(int xCoord, int yCoord, int age) {
		// System.out.print("x");
	}
}

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("");
	}
}

看一下執行結果：

最大記憶體 = 926941184
已分配記憶體 = 64487424
已分配記憶體中的剩餘空間 = 62465304
已用記憶體 = 2022120
時間 = 1539588509988

最大記憶體 = 926941184
已分配記憶體 = 145227776
已分配記憶體中的剩餘空間 = 22870040
已用記憶體 = 122357736
時間 = 1539588510873

最大記憶體 = 926941184
已分配記憶體 = 145227776
已分配記憶體中的剩餘空間 = 22870040
已用記憶體 = 122357736
時間 = 1539588510881

通過比較發現記憶體被佔用變小了，執行時間變小了。

其實享元模式就是通過共享細粒度物件的資料減少物件的資料的初始化或者是減少例項物件的建立。

再看一個更加複雜一點的例子。就是上面的景觀專案，我不只要栽樹，還要栽花。

這時候使用享元模式的設計的類圖如下所示：

在這裡插入圖片描述

我們把草和樹都抽象成為了一個plant的類，然後使用PlantManager來統一管理外部狀態資料。但是有人說當我需要放置雕像的時候怎麼辦呢？那就直接把雕像單獨作為一個類，然後抽象一個manager來做統一的管理。以後每新增一個物件要是可以抽象成為一組的就抽象，不能抽象成為一組的就直接單獨成為一類。

看一下具體的程式碼實現：

public class Tree extends Plant {

	@Override
	public void display(int xCoord, int yCoord, int age) {
		// TODO Auto-generated method stub
		// System.out.print("Tree x");
	}
}

public class Grass extends Plant {

	@Override
	public void display(int xCoord, int yCoord, int age) {
		// TODO Auto-generated method stub
		// System.out.print("Grass x");
	}
}

public abstract class Plant {

	public Plant() {

	}

	public abstract void display(int xCoord, int yCoord, int age);
}

public class PlantManager {

	private int length = 10000000;
	private int[] xArray = new int[length], yArray = new int[length],
			AgeArray = new int[length],	typeArray = new int[length];
	
	private PlantFactory mPlantFactory;
	public PlantManager() {
		
		mPlantFactory=new PlantFactory();
		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;
			typeArray[i]= (int) (Math.random() * length) % 2;
		}
	}
	
	public void displayTrees() {
		for (int i = 0; i < length; i++) {
			mPlantFactory.getPlant(typeArray[i]).display(xArray[i], yArray[i], AgeArray[i]);
			}
	}
}

public class PlantFactory {

	private HashMap<Integer, Plant> plantMap = new HashMap<Integer, Plant>();

	public PlantFactory() {

	}

	public Plant getPlant(int type) {

		if (!plantMap.containsKey(type)) {

			switch (type) {
			case 0:
				plantMap.put(0, new Tree());
				break;
			case 1:
				plantMap.put(1, new Grass());
				break;
			}
		}

		return plantMap.get(type);
	}
}

PlantFactory是用來管理和獲取具體的plant型別的。

public class MainTest {

	public static void main(String[] args) {

		showMemInfo();

		PlantManager mPlantManager;
		mPlantManager = new PlantManager();

		showMemInfo();
		mPlantManager.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("");
	}
}

看一下測試類的結果：

最大記憶體 = 926941184
已分配記憶體 = 64487424
已分配記憶體中的剩餘空間 = 62465304
已用記憶體 = 2022120
時間 = 1539589480028

最大記憶體 = 926941184
已分配記憶體 = 185597952
已分配記憶體中的剩餘空間 = 23240200
已用記憶體 = 162357752
時間 = 1539589481484

最大記憶體 = 926941184
已分配記憶體 = 185597952
已分配記憶體中的剩餘空間 = 23240200
已用記憶體 = 162357752
時間 = 1539589481658

通過結果我們可以看出儘管添加了一個新的類，但是記憶體佔用和執行時間還是比初始的時候要小。

所以可以看出享元模式的好處。

相關推薦

Head First設計模式之享元模式（蠅量模式）

logs sign face isp ria reat 定義 ogr sans 一、定義 享元模式（Flyweight Pattern）主要用於減少創建對象的數量，以減少內存占用和提高性能。這種類型的設計模式屬於結構型模式，它提供了減少對象數量從而改善應用所需的對象結構的

設計模式之享元模式（蠅量模式）

設計模式之享元模式（蠅量模式） 1. 什麼是享元模式 Flyweight模式也叫享元模式，是構造型模式之一，它通過與其他類似物件共享資料來減小記憶體佔用。 換句話說就是通過共享的方式高效地支援大量細粒度的物件。 享元模式的結構： 享元模式的角色和職責：

設計模式---對象性能模式之享元模式（Flyweight）

ret 大量 根據 利用 問題 字母 只讀 時代 帶來 一：概念 通過與其他類似對象共享數據來減少內存占用 如果一個應用程序使用了太多的對象， 就會造成很大的存儲開銷。 特別是對於大量輕量級 （細粒度）的對象，比如在文檔編輯器的設計過程中，我們如果為每個字母

設計模式之享元模式（Flyweight）

設計模式之享元模式（Flyweight） 本篇為https://github.com/iluwatar/java-design-patterns/tree/master/flyweight閱讀筆記 場景 煉金術士的商店裡擺滿了魔法藥水。許多藥水是相同的，因此不需要為每

設計模式之享元模式（Flyweight Pattern）

目的：主要用於減少建立物件的數量，以減少記憶體佔用和提高效能。 應用例項： 1、JAVA 中的 String，如果有則返回，如果沒有則建立一個字串儲存在字串快取池裡面。 2、資料庫的資料池。 程式碼： 畫圖形的 介面，描述畫這個動作： public interface Shape {

設計模式之享元模式（C++）

設計模式之享元模式 享元模式，運用共享技術有效地支援大量細粒度的物件。面向物件技術可以很好地解決一些靈活性或擴充套件性問題，但在很多情況下需要在系統中增加類和物件的個數。當物件數量太多時，將導致執行代價過高，帶來效能下降等問題。享元模式正式為了解決這依賴問題而誕

設計模式之享元模式（卷十一）

通過使用池的技術，有效減少了大量細粒度的物件的重複生成。 0x00 組織結構 Flyweight：抽象享元類，聲明瞭可以想外界提供內部狀態的方法，同時還可以設定外部狀態。 ConcreteFlyweight：具體享元類，通常和單例模式組合使用。 U

設計模式之享元模式（2）

本質 分離與共享。 程式碼示例 （1）定義描述授權資料的享元介面 package flyWeight; public interface FlyWeight { public b

23種設計模式之享元模式（結構型，7 Flyweight，c++實現）

程式碼實現：#include<iostream>#include<list>#include<string>#include<map>usingnamespace std;classPerson{public:Person(st

java設計模式之享元模式

並不是 計算 lov 這一 返回 實例 map() 角色 ron 當前咱們國家正在大力倡導構建和諧社會，其中一個很重要的組成部分就是建設資源節約型社會，“浪費可恥，節儉光榮”。在軟件系統中，有時候也會存在資源浪費的情況，例如在計算機內存中存儲了多個完全相同或者非常相似的

Java設計模式之享元模式實例詳解

AI ava flyweight lan trac home erro lin 代碼 本文實例講述了Java設計模式之享元模式。分享給大家供大家參考，具體如下： 解釋一下概念：也就是說在一個系統中如果有多個相同的對象，那麽只共享一份就可以了，不必每個都去實例化一個對象。比如

設計模式的藝術 結構性模式之享元模式

前言 知道圍棋的都知道圍棋有兩種顏色的棋子，黑色和白色，不同的地方就在於他們所放置的位置不同，大體是一樣的，所以廠家生產的時候也就是批量的進行生產，反正棋子放哪他們並不需要操心，在計算機中也會存在著很多相似的物件，如果相同的物件太多將導致系統執行代價過高，記憶體屬於計算機稀缺資源，不能隨便浪費，

設計模式 之 享元模式

info 如果能 實例化 應用 技術 一個 對象存儲 數量 col (一) 享元模式 　　享元模式 : 運用共享技術有效地支持大量細粒度的對象 　　 (二)內部狀態和外部狀態 　　在享元對象內部並且不會隨環境改變而改變的共享部分,可以稱為是享元對象的內部狀態,而隨環

設計模式之享元模式

享元模式定義 享元模式（Flyweight Pattern）是池技術的重要實現方式，使用共享物件可有效地支援大量的細粒度的物件。 通用類圖 具體實現 當應用程式中存在大量的物件時，程式的效能會有所下降，而且可能會造成記憶體溢位。這時除了增加硬體資源或者借用

每天一個設計模式之享元模式

作者按：《每天一個設計模式》旨在初步領會設計模式的精髓，目前採用javascript和python兩種語言實現。誠然，每種設計模式都有多種實現方式，但此小冊只記錄最直截了當的實現方式 :) 個人技術部落格-godbmw.com 歡迎來玩! 每週至少 1 篇原創技術分享，還有開源教程(webpack

23種設計模式之享元模式

享元模式的定義 定義: 使用共享物件可有效的支援大量的細粒度的物件 通俗的說, 就是將類的通用屬性抽出來,建立物件池,以達到限制物件數量的效果 上面定義中要求細粒度物件, 那麼不可避免的使得物件數量多且性質相近, 我們將這些物件的資訊分為兩個部分: 內部狀態和外部狀態 內部狀態是物件可以共享出來

設計模式之享元模式(結構型)

程序 aid 共享 對象 ron map 內部 系統 抽象 模式定義 享元模式(Flyweight Pattern)就是通過共享技術實現大量細粒度對象的復用。享元模式是通過細粒度對象的共享，所以也可以說享元模式是一種輕量級模式。按照Gof模式分類，享元模式屬於對象結構型模式

C#--設計模式之享元模式

這幾天專案比較忙，感覺已經隔了半個世紀沒來園裡轉了，接著上次的設計模式來繼續說吧，這會來敘說一下享元模式，首先應用場景：就是在  我們需要重複使用某個物件的時候，如果我們重複地使用new建立這個物件的話，這樣我們在記憶體就需要多次地去申請記憶體空間了，這樣可能會出現記憶

設計模式之——享元設計模式

享元模式（Flyweight Pattern）主要用於減少建立物件的數量，以減少記憶體佔用和提高效能。這種型別的設計模式屬於結構型模式，它提供了減少物件數量從而改善應用所需的物件結構的方式。享元模式嘗試重用現有的同類物件，如果未找到匹配的物件，則建立新物件。所以其核心就是控

c#設計模式之享元模式

//類似單例模式加上工廠模式,避免大量建立物件帶來的記憶體消耗 using System; using System.Collections; public abstract class cha