设计模式十九之享元模式

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

介绍

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

定义

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

使用场景

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

UML 类图

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

代码示例

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

展示车票信息接口

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

展示车票具体实现:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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);

}
}

车票信息管理:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@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:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
创建对象 = [北京], to = [上海]
购买从北京 -> 上海的 上铺 火车票 ,价格:36
使用存在的对象 = [北京], to = [上海]
购买从北京 -> 上海的 下铺 火车票 ,价格:261
使用存在的对象 = [北京], to = [上海]
购买从北京 -> 上海的 上铺 火车票 ,价格:100
使用存在的对象 = [北京], to = [上海]
购买从北京 -> 上海的 上铺 火车票 ,价格:247
创建对象 = [北京], to = [成都]
购买从北京 -> 成都的 下铺 火车票 ,价格:224
使用存在的对象 = [北京], to = [上海]
购买从北京 -> 上海的 上铺 火车票 ,价格:262
使用存在的对象 = [北京], to = [上海]
购买从北京 -> 上海的 上铺 火车票 ,价格:114

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

总结

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

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

  • 享元模式使得系统更加复杂。为了使对象可以共享,需要将一些状态外部化,这使得程序的逻辑复杂化。
  • 享元模式将享元对象的状态外部化,而读取外部状态使得运行时间稍微变长。
坚持原创技术分享,您的支持将鼓励我继续创作!