当前位置：首页 > news >正文

设计模式之享元模式详解（FlyWeight Pattern）

news 来源：原创 2024/4/27 6:10:47

在面向对象程序设计过程中，有时会面临要创建大量相同或相似对象实例的问题。创建那么多的对象将会耗费很多的系统资源，它是系统性能提高的一个瓶颈。
例如，围棋和五子棋中的黑白棋子，图像中的坐标点或颜色，局域网中的路由器、交换机和集线器，教室里的桌子和凳子等。
这些对象有很多相似的地方，如果能把它们相同的部分提取出来共享，则能节省大量的系统资源，这就是享元模式的产生背景。

定义与优缺点

享元（Flyweight）模式的定义：运用共享技术来有効地支持大量细粒度对象的复用。它通过共享已经存在的又橡来大幅度减少需要创建的对象数量、避免大量相似类的开销，从而提高系统资源的利用率。

享元模式的主要优点是：相同对象只要保存一份，这降低了系统中对象的数量，从而降低了系统中细粒度对象给内存带来的压力。

其主要缺点是：

为了使对象可以共享，需要将一些不能共享的状态外部化，这将增加程序的复杂性。
读取享元模式的外部状态会使得运行时间稍微变长。

结构

基本介绍

享元模式提出了两个要求：细粒度和共享对象。这里就涉及到内部状态和外部状态了，即将对象的信息分为两个部分：内部状态和外部状态
内部状态指对象共享出来的信息，存储在享元对象内部且不会随环境的改变而改变
外部状态指对象得以依赖的一个标记，是随环境改变而改变的、不可共享的状态。
举个例子：围棋理论上有 361 个空位可以放棋子，每盘棋都有可能有两三百个棋子对象产生，因为内存空间有限，一台服务器很难支持更多的玩家玩围棋游戏，如果用享元模式来处理棋子，那么棋子对象就可以减少到只有两个实例，这样就很好的解决了对象的开销问题，棋子颜色就是棋子的内部状态，棋子坐标就是棋子的外部状态。

原理类图

在这里插入图片描述
模式的角色及职责

抽象享元角色（Flyweight）:是所有的具体享元类的基类，为具体享元规范需要实现的公共接口，非享元的外部状态以参数的形式通过方法传入。
具体享元（Concrete Flyweight）角色：实现抽象享元角色中所规定的接口。
非享元（Unsharable Flyweight)角色：是不可以共享的外部状态，它以参数的形式注入具体享元的相关方法中。
享元工厂（Flyweight Factory）角色：负责创建和管理享元角色。当客户对象请求一个享元对象时，享元工厂检査系统中是否存在符合要求的享元对象，如果存在则提供给客户；如果不存在的话，则创建一个新的享元对象。

模式的实现

//客户端使用
public class Client {
    public static void main(String[] args) {
        FlyWeightFactory factory=new FlyWeightFactory();
        
        FlyWeight f01=factory.getFlyWeight("a");
        FlyWeight f02=factory.getFlyWeight("a");
        FlyWeight f03=factory.getFlyWeight("a");
        
        FlyWeight f11=factory.getFlyWeight("b");
        FlyWeight f12=factory.getFlyWeight("b");
        
        f01.operation(new UnSharedConcreteFlyWeight("第1次调用a。"));
        f02.operation(new UnSharedConcreteFlyWeight("第2次调用a。"));
        f03.operation(new UnSharedConcreteFlyWeight("第3次调用a。"));
        f11.operation(new UnSharedConcreteFlyWeight("第1次调用b。"));
        f12.operation(new UnSharedConcreteFlyWeight("第2次调用b。"));
    }
}

//抽象享元角色
public interface FlyWeight {
    public void operation(UnSharedConcreteFlyWeight state);
}

//具体享元角色
public class ConcreteFlyWeight implements FlyWeight {

    private String key;

    ConcreteFlyWeight(String key) {
        this.key = key;
        System.out.println("具体享元"+key+"被创建");
    }

    @Override
    public void operation(UnSharedConcreteFlyWeight outState) {
        System.out.print("具体享元"+key+"被调用，");
        System.out.println("非享元信息是:"+outState.getInfo());
    }
}

//非享元角色
public class UnSharedConcreteFlyWeight {
    private String info;

    public String getInfo() {
        return info;
    }

    public void setInfo(String info) {
        this.info = info;
    }

    UnSharedConcreteFlyWeight(String info) {
        this.info = info;
    }
}

//享元工厂角色
public class FlyWeightFactory {
    private HashMap<String,FlyWeight> flyWeights = new HashMap<>();

    public FlyWeight getFlyWeight(String key) {
        FlyWeight flyWeight = flyWeights.get(key);
        if (flyWeight != null) {
            System.out.println("具体享元"+key+"已经存在，被成功获取！");
        } else {
            flyWeight = new ConcreteFlyWeight(key);
            flyWeights.put(key,flyWeight);
        }
        return flyWeight;
    }
}

应用场景

统中存在大量相同或相似的对象，这些对象耗费大量的内存资源。
大部分的对象可以按照内部状态进行分组，且可将不同部分外部化，这样每一个组只需保存一个内部状态。
由于享元模式需要额外维护一个保存享元的数据结构，所以应当在有足够多的享元实例时才值得使用享元模式。

模式扩展

在前面介绍的享元模式中，其结构图通常包含可以共享的部分和不可以共享的部分。在实际使用过程中，有时候会稍加改变，即存在两种特殊的享元模式：单纯享元模式和复合享元模式，下面分别对它们进行简单介绍。
(1) 单纯享元模式，这种享元模式中的所有的具体享元类都是可以共享的，不存在非共享的具体享元类，其结构图如下图所示。
单纯享元模式的结构图
(2) 复合享元模式，这种享元模式中的有些享元对象是由一些单纯享元对象组合而成的，它们就是复合享元对象。虽然复合享元对象本身不能共享，但它们可以分解成单纯享元对象再被共享，其结构图如下图所示。
复合享元模式的结构图

享元模式在 JDK-Interger 的应用源码分析

public class FlyWeight {
	public static void main(String[] args) {
		//如果  Integer.valueOf(x) x 在	-128 --- 127 直接，就是使用享元模式返回,如果不在范围类，则仍然 new
		
		//小结:
		//1. 在 valueOf 方法中，先判断值是否在 IntegerCache 中，如果不在，就创建新的 Integer(new),  否则，就直接从 缓存池返回
		//2. valueOf 方法，就使用到享元模式
		//3. 如果使用 valueOf 方法得到一个 Integer 实例，范围在 -128 - 127  ，执行速度比 new 快
		
		Integer x = Integer.valueOf(127); // 得到 x 实例，类型 Integer 
		Integer y = new Integer(127); // 得 到 y 实 例 ， 类 型 Integer
		Integer z = Integer.valueOf(127);//..
		Integer w = new Integer(127);
		
		System.out.println(x.equals(y)); // 大小，true 
		System.out.println(x == y ); //	false 
		System.out.println(x == z ); // true 
		System.out.println(w == x ); // false 
		System.out.println(w == y ); // false
		
		Integer x1 = Integer.valueOf(200); //不在IntegerCache中，创建新的 Integer(new)
		Integer x2 = Integer.valueOf(200);//不在IntegerCache中，创建新的 Integer(new)
	
		System.out.println("x1==x2" + (x1 == x2)); // false
	}
}

参考文章：
享元模式（详解版）