在面向对象程序设计过程中,有时会面临要创建大量相同或相似对象实例的问题。创建那么多的对象将会耗费很多的系统资源,它是系统性能提高的一个瓶颈。
例如,围棋和五子棋中的黑白棋子,图像中的坐标点或颜色,局域网中的路由器、交换机和集线器,教室里的桌子和凳子等。这些对象有很多相似的地方,如果能把它们相同的部分提取出来共享,则能节省大量的系统资源,这就是享元模式的产生背景。
享元(Flyweight)模式的定义:顾名思义,利用JVM中的不同变量存储相同地址指向与操作同一片内存空间的特性,实现的对象共享技术,来有效地支持大量细粒度对象的复用。它通过共享已经存在的对象来大幅度减少需要创建的对象数量、避免大量相似类的开销,从而提高系统资源的利用率。
享元模式的主要优点是:相同对象只要保存一份,这降低了系统中对象的数量,从而降低了系统中细粒度对象给内存带来的压力。
其主要缺点是:
享元模式的定义提出了两个要求,细粒度和共享对象。因为要求细粒度,所以不可避免地会使对象数量多且性质相近,此时我们就将这些对象的信息分为两个部分:内部状态和外部状态。
比如,连接池中的连接对象,保存在连接对象中的用户名、密码、连接URL等信息,在创建对象的时候就设置好了,不会随环境的改变而改变,这些为内部状态。而当每个连接要被回收利用时,我们需要将它标记为可用状态,这些为外部状态。
享元模式的本质是缓存共享对象,降低内存消耗。
享元模式的主要角色有如下:
图 1 是享元模式的结构图,其中:
享元模式的实现代码如下:
public class FlyweightPattern {
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。"));
}
}
//非享元角色
class UnsharedConcreteFlyweight {
private String info;
UnsharedConcreteFlyweight(String info) {
this.info = info;
}
public String getInfo() {
return info;
}
public void setInfo(String info) {
this.info = info;
}
}
//抽象享元角色
interface Flyweight {
public void operation(UnsharedConcreteFlyweight state);
}
//具体享元角色
class ConcreteFlyweight implements Flyweight {
private String key;
ConcreteFlyweight(String key) {
this.key = key;
System.out.println("具体享元" + key + "被创建!");
}
public void operation(UnsharedConcreteFlyweight outState) {
System.out.print("具体享元" + key + "被调用,");
System.out.println("非享元信息是:" + outState.getInfo());
}
}
//享元工厂角色
class FlyweightFactory {
private HashMap<String, Flyweight> flyweights = new HashMap<String, Flyweight>();
public Flyweight getFlyweight(String key) {
Flyweight flyweight = (Flyweight) flyweights.get(key);
if (flyweight != null) {
System.out.println("具体享元" + key + "已经存在,被成功获取!");
} else {
flyweight = new ConcreteFlyweight(key);
flyweights.put(key, flyweight);
}
return flyweight;
}
}
程序运行结果如下:
具体享元a被创建!
具体享元a已经存在,被成功获取!
具体享元a已经存在,被成功获取!
具体享元b被创建!
具体享元b已经存在,被成功获取!
具体享元a被调用,非享元信息是:第1次调用a。
具体享元a被调用,非享元信息是:第2次调用a。
具体享元a被调用,非享元信息是:第3次调用a。
具体享元b被调用,非享元信息是:第1次调用b。
具体享元b被调用,非享元信息是:第2次调用b。
商品秒杀,很多家商铺同时参加,且其中一商品的信息是不变的,但不同的商铺的库存是不同的且会随着变化的。
此时商品信息就是内部状态,是不变的;库存是外部状态,是会变化的。
抽象共享角色–商品
public interface Commodity {
/**
* 售出
* @param inventory
*/
void sell(Inventory inventory);
}
非共享角色–库存
public class Inventory {
/**
* 商品库存
*/
private int num ;
public Inventory(int num) {
this.num = num;
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
}
具体共享角色–手机商品
public class Phone implements Commodity {
private String description;
public Phone(String description) {
this.description = description;
System.out.println("商品 : " + this.description + " 被创建了。");
}
@Override
public void sell(Inventory inventory) {
int num = inventory.getNum();
System.out.println(this.description + "将被售出 ,当前库存 : " + num);
System.out.println("商品 : " + this.description + " 被售出。");
inventory.setNum(--num);
System.out.println("商品售出后库存 : " + num);
}
}
具体共享角色–拖鞋
public class Slipper implements Commodity {
private String description;
public Slipper(String description) {
this.description = description;
}
@Override
public void sell(Inventory inventory) {
int num = inventory.getNum();
System.out.println(this.description + "将被售出 ,当前库存 : " + num);
System.out.println("商品 : " + this.description + " 被售出。");
inventory.setNum(--num);
System.out.println("商品售出后库存 : " + num);
}
}
享元工厂
public class CommodityFactory {
private Map<String, Commodity> commodityMap = new HashMap<String, Commodity>();
public Commodity getCommodityInstance(String key) {
if (!commodityMap.containsKey(key)) {
if ("拖鞋".equals(key)) {
commodityMap.put(key,new Slipper("超级拖鞋(航天品质)"));
} else if ("手机".equals(key)) {
commodityMap.put(key,new Phone("超级手机(聚变发电)"));
} else {
throw new RuntimeException("不存在的手机型号");
}
}
return commodityMap.get(key);
}
}
入口函数
public class AppMain {
public static void main(String[] args) {
CommodityFactory commodityFactory = new CommodityFactory();
System.out.println("-------商品1-------");
/**
* 现有四家店铺,销售描述相同的手机,但每家点的库存不一样
*/
// 店铺1
Commodity phone1 = commodityFactory.getCommodityInstance("手机");
phone1.sell(new Inventory(1000));
// 店铺2
Commodity phone2 = commodityFactory.getCommodityInstance("手机");
phone2.sell(new Inventory(900));
// 店铺3
Commodity phone3 = commodityFactory.getCommodityInstance("手机");
phone3.sell(new Inventory(800));
// 店铺4
Commodity phone4 = commodityFactory.getCommodityInstance("手机");
phone4.sell(new Inventory(300));
System.out.println("========校验是否是相同对象========");
System.out.println("phone1 == phone2 ? " + (phone1 == phone2));
System.out.println("phone2 == phone3 ? " + (phone2 == phone3));
System.out.println("phone3 == phone4 ? " + (phone3 == phone4));
System.out.println("-------商品2------测试略---");
Commodity slipper = commodityFactory.getCommodityInstance("拖鞋");
slipper.sell(new Inventory(10));
}
}
当系统中多处需要同一组信息时,可以把这些信息封装到一个对象中,然后对该对象进行缓存,这样,一个对象就可以提供给多出需要使用的地方,避免大量同一对象的多次创建,降低大量内存空间的消耗。
享元模式其实是工厂方法模式的一个改进机制,享元模式同样要求创建一个或一组对象,并且就是通过工厂方法模式生成对象的,只不过享元模式为工厂方法模式增加了缓存这一功能。
前面分析了享元模式的结构与特点,下面分析它适用的应用场景。享元模式是通过减少内存中对象的数量来节省内存空间的,所以以下几种情形适合采用享元模式。
系统中存在大量相同或相似的对象,这些对象耗费大量的内存资源。
大部分的对象可以按照内部状态进行分组,且可将不同部分外部化,这样每一个组只需保存一个内部状态。
由于享元模式需要额外维护一个保存享元的数据结构,所以应当在有足够多的享元实例时才值得使用享元模式。
在前面介绍的享元模式中,其结构图通常包含可以共享的部分和不可以共享的部分。在实际使用过程中,有时候会稍加改变,即存在两种特殊的享元模式:单纯享元模式和复合享元模式,下面分别对它们进行简单介绍。
(1) 单纯享元模式,这种享元模式中的所有的具体享元类都是可以共享的,不存在非共享的具体享元类,其结构图如图 4 所示。
(2) 复合享元模式,这种享元模式中的有些享元对象是由一些单纯享元对象组合而成的,它们就是复合享元对象。虽然复合享元对象本身不能共享,但它们可以分解成单纯享元对象再被共享。
如果希望为多个内部状态不同的享元对象设置相同的外部状态(在上面商品销售案例中,可以理解为给拖鞋**[可以为拖鞋新加一个方法show,用于和手机区别]**和手机分别设置相同的库存),可以考虑使用复合享元模式。
设计模式-C语言中文网