享元(轻量级)模式

简介

享元模式(Flyweight Pattern)又叫作轻量级模式,是对象池的一种实现。类似线程池,线程池可以避免不停地创建和销毁多个对象,消耗性能。享元模式提供了减少对象数量从而改善应用所需的对象结构的方式。其宗旨是共享细粒度对象,将多个对同一对象的访问集中起来,不必为每个访问者都创建一个单独的对象,以此来降低内存的消耗,属于结构型设计模式。

享元(Flyweight)的核心思想很简单:如果一个对象实例一经创建就不可变,那么反复创建相同的实例就没有必要,直接向调用方返回一个共享的实例就行,这样即节省内存,又可以减少创建对象的过程,提高运行速度。

通用模板

  1. 创建抽象享元角色:享元对象抽象基类或者接口。

    java 复制代码
    // 享元接口
    public interface IFlyweight {
        void operation(String extrinsicState);
    }
  2. 创建具体享元角色:实现抽象角色定义的业务。

    java 复制代码
    // 具体的享元角色
    public class FlyWeight implements IFlyweight {
        private String intrinsicState;
    
        public FlyWeight(String intrinsicState) {
            this.intrinsicState = intrinsicState;
        }
    
        @Override
        public void operation(String extrinsicState) {
            System.out.println("Object address: " + System.identityHashCode(this));
            System.out.println("IntrinsicState: " + this.intrinsicState);
            System.out.println("ExtrinsicState: " + extrinsicState);
        }
    }
  3. 创建享元工厂::负责管理享元对象池和创建享元对象。

    java 复制代码
    import java.util.HashMap;
    import java.util.Map;
    // 享元工厂
    public class FlyweightFactory {
        private static Map<String, IFlyweight> pool = new HashMap<String, IFlyweight>();
    
        // 因为内部状态具备不变性,因此作为缓存的键
        public static IFlyweight getFlyweight(String intrinsicState) {
            if (!pool.containsKey(intrinsicState)) {
                IFlyweight flyweight = new FlyWeight(intrinsicState);
                pool.put(intrinsicState, flyweight);
            }
            return pool.get(intrinsicState);
        }
    }

模板测试

  1. 代码

    java 复制代码
    public class Client {
        public static void main(String[] args) {
            IFlyweight flyweight1 = FlyweightFactory.getFlyweight("aa");
            IFlyweight flyweight2 = FlyweightFactory.getFlyweight("aa");
            flyweight1.operation("aa");
            flyweight2.operation("b");
        }
    }
  2. 结果

    java 复制代码
    Object address: 2133927002
    IntrinsicState: aa
    ExtrinsicState: aa
    Object address: 2133927002
    IntrinsicState: aa
    ExtrinsicState: b

内部状态和外部状态

享元模式的定义提出了两个要求:细粒度和共享对象。因为要求细粒度,所以不可避免地会使对象数量多且性质相近,此时我们就将这些对象的信息分为两个部分:内部状态和外部状态。

内部状态指对象共享出来的信息,存储在享元对象内部,并且不会随环境的改变而改变;外部状态指对象得以依赖的一个标记,随环境的改变而改变,不可共享。

比如,连接池中的连接对象,保存在连接对象中的用户名、密码、连接URL等信息,在创建对象的时候就设置好了,不会随环境的改变而改变,这些为内部状态。而当每个连接要被回收利用时,我们需要将它标记为可用状态,这些为外部状态。

应用场景

在生活中,享元模式非常常见,比如各中介机构的房源共享,再比如全国社保联网。 当系统中多处需要同一组信息时,可以把这些信息封装到一个对象中,然后对该对象进行缓存,这样,一个对象就可以提供给多处需要使用的地方,避免大量同一对象的多次创建,降低大量内存空间的消耗。 享元模式其实是工厂方法模式的一个改进机制,享元模式同样要求创建一个或一组对象,并且就是通过工厂方法模式生成对象的,只不过享元模式为工厂方法模式增加了缓存这一功能。主要应用场景如下。 (1)常应用于系统底层的开发,以便解决系统的性能问题。

(2)系统有大量相似对象、需要缓冲池的场景。

优点

(1)减少对象的创建,降低内存中对象的数量,降低系统的内存,提高效率。

(2)减少内存之外的其他资源占用。

缺点

(1)关注内、外部状态,关注线程安全问题。

(2)使系统、程序的逻辑复杂化。

"生搬硬套"实战

场景描述

一个典型的享元模式的应用场景是在处理大量细粒度对象时,比如在一个文字处理软件中表示文档中的字符。如果每个字符都作为一个独立的对象创建,那么对于一个包含数千字符的文档来说,将会有大量的对象被创建,这会消耗大量的内存。使用享元模式可以有效地减少内存使用,因为相同的字符可以被多个位置共享。

代码开发

根据模板我们知道抽象工厂和工厂方法模式一样也是拢共就是3步:

  1. 创建抽象享元角色(这里指的是字符享元接口)

    java 复制代码
    // 字符享元接口
    public interface ICharFlyweight {
        // 展示字符位置的方法
        void display(int position);
    }
  2. 创建具体享元角色(这里指的是字符对象的具体类)

    java 复制代码
    // 具体的字符享元实现
    public class ConcreteCharFlyweight implements ICharFlyweight {
        private final char character;
    
        public ConcreteCharFlyweight(char character) {
            this.character = character;
        }
    
        @Override
        public void display(int position) {
            System.out.println("Displaying '" + character + "' at position " + position);
        }
    }
  3. 创建享元工厂(这里指的是创建字符对象的工厂)

    java 复制代码
    // 创建字符对象的工厂,如果字符对象已经存在,则直接使用,否则存储起来备用
    public class FlyweightFactory {
        private static final Map<Character, ICharFlyweight> pool = new HashMap<Character, ICharFlyweight>();
    
        public static ICharFlyweight getCharFlyweight(char character) {
            ICharFlyweight flyweight = pool.get(character);
            if (flyweight == null) {
                flyweight = new ConcreteCharFlyweight(character);
                pool.put(character, flyweight);
            }
            return flyweight;
        }
    }

至此,我们就通过"生搬硬套"享元模式的模板设计出一套对象池开发流程,接下来我们进行测试:

  • 测试代码

    java 复制代码
    public class Demo {
        public static void main(String[] args) {
            String text = "Hello World!";
            for (int i = 0; i < text.length(); i++) {
                char c = text.charAt(i);
                ICharFlyweight flyweight = FlyweightFactory.getCharFlyweight(c);
                flyweight.display(i);
            }
        }
    }
  • 结果

    java 复制代码
    Displaying 'H' at position 0
    Displaying 'e' at position 1
    Displaying 'l' at position 2
    Displaying 'l' at position 3
    Displaying 'o' at position 4
    Displaying ' ' at position 5
    Displaying 'W' at position 6
    Displaying 'o' at position 7
    Displaying 'r' at position 8
    Displaying 'l' at position 9
    Displaying 'd' at position 10
    Displaying '!' at position 11

这样每当有已经出现过的字符出现,则复用对象。

总结

享元模式的本质是缓存共享对象,降低内存消耗。

相关推荐
G皮T9 天前
【设计模式】结构型模式(四):组合模式、享元模式
java·设计模式·组合模式·享元模式·composite·flyweight
有点困的拿铁10 天前
Java中的享元模式
java·开发语言·享元模式
morning_judger13 天前
【设计模式系列】享元模式(十五)
java·设计模式·享元模式
Mr. zhihao13 天前
享元模式及其运用场景:结合工厂模式和单例模式优化内存使用
单例模式·享元模式
老攀呀13 天前
Flyweight(享元)
享元模式
Mr. zhihao15 天前
享元模式在 JDK 中的应用解析
java·享元模式
wrx繁星点点15 天前
享元模式:高效管理共享对象的设计模式
java·开发语言·spring·设计模式·maven·intellij-idea·享元模式
balong.18 天前
享元模式-实现大颗粒度对象缓存机制
享元模式
无敌岩雀18 天前
C++设计模式结构型模式———享元模式
开发语言·c++·设计模式·享元模式
zzzhpzhpzzz22 天前
设计模式——享元模式
算法·设计模式·享元模式