设计模式十九之享元模式

通过理论,代码示例,Android源码来学习享元模式

介绍

享元模式是对象池的一种实现，享元模式用来尽可能减少内存使用量，它适合用于可能存在大量重复对象的场景，来缓存可共享的对象，达到对象共享、避免创建过多对象的效果，这样一来就可以提升性能、避免内存移除等。

定义

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

使用场景

• 系统中存在大量的相似对象。
• 细粒度的对象都具备较接近的外部状态，而且内部状态与环境无关，也就是说对象没有特定身份。
• 需要缓冲池的场景。

UML 类图

• Flyweiget : 享元对象抽象基类或者接口
• ConcreteFlyweiget: 具体的享元对象。
• FlyweigetFactory: 享元工厂，负责管理享元对象池和创建享元对象。

代码示例

需求背景: 过年回家买车票，如果在并发 1W 人次同时 http 请求数据，如果后台每次都重新创建一个查询的车票结果，那么必然会造成大量重复对象的创建、销毁、使得 GC 任务繁重、内存高居不下。

展示车票信息接口

public interface Ticket {
    public void showTicketInfo(String info);
}

展示车票具体实现:

public class TrainTicket implements Ticket {
    public String from;
    public String to;
    public String bunk;
    public int price;

    public TrainTicket(String from, String to) {
        this.from = from;
        this.to = to;
    }

    @Override
    public void showTicketInfo(String info) {
        bunk = info;
        price = new Random().nextInt(300);
        System.out.println("购买从" + from + " -> " + to + "的 " + bunk + " 火车票 ，价格：" + price);

    }
}

车票信息管理:

public class TicketFactory {

    static Map<String, Ticket> sTicketMap = new ConcurrentHashMap<>();

    public static Ticket getTicket(String from, String to) {
        String key = from + "-" + to;
        if (sTicketMap.containsKey(key)) {
            //使用已经存在的对象
            System.out.println("使用存在的对象 = [" + from + "], to = [" + to + "]");
            return sTicketMap.get(key);
        } else {
            System.out.println("创建对象 = [" + from + "], to = [" + to + "]");
            TrainTicket trainTicket = new TrainTicket(from, to);
            sTicketMap.put(key, trainTicket);
            return trainTicket;
        }

    }
}

test:

@Test
public void testFlaweiget(){
    Ticket ticket1 = TicketFactory.getTicket("北京", "上海");
    ticket1.showTicketInfo("上铺");
    Ticket ticket7 = TicketFactory.getTicket("北京", "上海");
    ticket7.showTicketInfo("下铺");
    Ticket ticket2 = TicketFactory.getTicket("北京", "上海");
    ticket2.showTicketInfo("上铺");
    Ticket ticket3 = TicketFactory.getTicket("北京", "上海");
    ticket3.showTicketInfo("上铺");
    Ticket ticket4 = TicketFactory.getTicket("北京", "成都");
    ticket4.showTicketInfo("下铺");
    Ticket ticket5 = TicketFactory.getTicket("北京", "上海");
    ticket5.showTicketInfo("上铺");
    Ticket ticket6 = TicketFactory.getTicket("北京", "上海");
    ticket6.showTicketInfo("上铺");
}

output:

创建对象 = [北京], to = [上海]
购买从北京 -> 上海的 上铺 火车票 ，价格：36
使用存在的对象 = [北京], to = [上海]
购买从北京 -> 上海的 下铺 火车票 ，价格：261
使用存在的对象 = [北京], to = [上海]
购买从北京 -> 上海的 上铺 火车票 ，价格：100
使用存在的对象 = [北京], to = [上海]
购买从北京 -> 上海的 上铺 火车票 ，价格：247
创建对象 = [北京], to = [成都]
购买从北京 -> 成都的 下铺 火车票 ，价格：224
使用存在的对象 = [北京], to = [上海]
购买从北京 -> 上海的 上铺 火车票 ，价格：262
使用存在的对象 = [北京], to = [上海]
购买从北京 -> 上海的 上铺 火车票 ，价格：114

从上面的查询结果得知，如果已经查询了就使用缓存，没有就创建对象。

总结

享元模式是实现比较简单，但是它的作用在某些场景确实极其重要的。它可以大大减少应用程序创建的对象，降低程序内存的占用，增强程序的性能，但它同时也提高了系统的复杂性，需要分离出外部状态和内部状态，而且外部状态具有固化特性，不应该随内部状态改变而改变，否则导致系统的逻辑混乱。

享元模式的有点在于大幅度地降低内存中对象的数量。但是，它做到这一点所付出的代价也是很高的。

• 享元模式使得系统更加复杂。为了使对象可以共享，需要将一些状态外部化，这使得程序的逻辑复杂化。
• 享元模式将享元对象的状态外部化，而读取外部状态使得运行时间稍微变长。