享元模式（Flyweight Pattern）

Posted 2021-07-23 顧棟

文章目录

• 享元模式（Flyweight Pattern）
• • 享元模式的定义
  • 享元模式的结构
  • 享元模式的优点
  • 享元模式的缺点
  • 享元模式的实现
  • 享元模式的使用场景

享元模式（Flyweight Pattern）

享元模式的定义

使用共享对象可有效地支持大量的细粒度的对象。

享元模式其实是工厂方法模式的一个改进机制，享元模式同样要求创建一个或一组对象，并且就是通过工厂方法模式生成对象的，只不过享元模式为工厂方法模式增加了缓存这一功能。

享元模式的结构

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

• 内部状态指对象共享出来的信息，存储在享元信息内部，并且不会随环境的改变而改变；它们可以作为一个对象的动态附加信息，不必直接储存
  在具体某个对象中，属于可以共享的部分。
• 外部状态指对象得以依赖的一个标记，随环境的改变而改变，不可共享的状态。

享元模式的主要角色有如下。

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

享元模式的优点

• 减少程序创建对象的数量，降低内存的占用，提高性能。

享元模式的缺点

• 为了使对象可以共享，需要将一些不能共享的状态外部化，这将增加程序的复杂性。

• 读取享元模式的外部状态会使得运行时间稍微变长。

享元模式的实现

public interface ActivityInfo {
    public void op(Stock stock);
}

/**
 * 不变的数据，活动信息
 */
public class Activity {
    /**
     * 活动ID
     */
    private Long id;
    /**
     * 活动名称
     */
    private String name;
    /**
     * 活动描述
     */
    private String desc;
    /**
     * 开始时间
     */
    private Date startTime;
    /**
     * 结束时间
     */
    private Date stopTime;
    /**
     * 活动库存
     */
    private Stock stock;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }

    public Date getStartTime() {
        return startTime;
    }

    public void setStartTime(Date startTime) {
        this.startTime = startTime;
    }

    public Date getStopTime() {
        return stopTime;
    }

    public void setStopTime(Date stopTime) {
        this.stopTime = stopTime;
    }

    public Stock getStock() {
        return stock;
    }

    @Override
    public void op(Stock stock) {
        this.stock = stock;
    }
}

/**
 * 变化的库存信息
 */
public class Stock {
    /**
     * 库存总量
     */
    private int total;
    /**
     * 库存已用
     */
    private int used;
    
    public Stock(int total, int used) {
        this.total = total;
        this.used = used;
    }

    public int getTotal() {
        return total;
    }

    public void setTotal(int total) {
        this.total = total;
    }

    public int getUsed() {
        return used;
    }

    public void setUsed(int used) {
        this.used = used;
    }
}

public class RedisUtils {
    private final ScheduledExecutorService scheduledExecutorService = new ScheduledThreadPoolExecutor(1
            , new BasicThreadFactory.Builder().namingPattern("redis-schedule-pool-%d").daemon(true).build());

    private AtomicInteger stock = new AtomicInteger(0);

    public RedisUtils() {
        scheduledExecutorService.scheduleAtFixedRate(() -> {
            // 模拟库存消耗
            stock.addAndGet(1);
        }, 0, 100000, TimeUnit.MICROSECONDS);

    }

    public int getStockUsed() {
        return stock.get();
    }
}

public class ActivityFactory {
    static Map<Long, Activity> activityMap = new HashMap<Long, Activity>();

    public static Activity getActivity(Long id) {
        Activity activity = activityMap.get(id);
        if (null == activity) {
            // 模拟从实际业务应用从接口中获取活动信息
            activity = new Activity();
            activity.setId(10001L);
            activity.setName("图书嗨乐");
            activity.setDesc("图书优惠券分享激励分享活动第二期");
            activity.setStartTime(new Date());
            activity.setStopTime(new Date());
            activityMap.put(id, activity);
        }
        return activity;
    }
}

public class ActivityController {

    private RedisUtils redisUtils = new RedisUtils();

    public Activity queryActivityInfo(Long id) {
        Activity activity = ActivityFactory.getActivity(id);
        // 模拟从Redis中获取库存变化信息
        Stock stock = new Stock(1000, redisUtils.getStockUsed());
        activity.op(stock);
        return activity;
    }
}

public static void main(String[] args) throws InterruptedException {
    ActivityController activityController = new ActivityController();
    for (int idx = 0; idx < 10; idx++) {
        Long req = 10001L;
        Activity activity = activityController.queryActivityInfo(req);
        System.out.println("测试结果：{" + req + "} {" + JSON.toJSONString(activity) + "}");
        Thread.sleep(1200);
    }
}

享元模式的使用场景

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

---

本文主要参考：

1. 小傅哥的《重学Java模式》
2. 《C语言中文网》设计模式的相关内容
3. 《设计模式之禅》第二版 秦小波