一、概述
1、定义
Use sharing to support large numbers of fine-grained objects efficiently.(使用共享对象可有效地支持大量的细粒度的对象。)
2、通用类图
3、基本介绍
- 享元模式可以通过运用共享技术有效的支持大量细粒度的对象;
- 享元模式常用于系统底层的开发,解决系统的性能问题,例如数据库连接池,里面都是创建好的对象,我们使用的时候如果池中有就直接拿来用,否则就创建一个;
- 享元模式能够解决重复对象的内存浪费问题,当系统中有大量相似对象,需要缓冲池时。不需要总是创建对象,可以从缓冲池中拿。这样可以降低系统内存,同时提高效率;
- 享元模式要求细粒度对象,那么就会使得对象数量多且性质相近,因此我们将对象信息分为两个部分:内部状态(intrinsic) 和外部状态(extrinsic):
- 内部状态:对象共享出来的信息,存储在享元对象内部并且不会随环境改变而改变;
- 外部状态:是对象得以依赖的一个标记,是随环境的改变而改变的,不可以共享的状态;
二、通用源码
抽象享元角色:
一个定义出对象的外部状态和内部状态的接口或实现的抽象类。
public abstract class Flyweight {
//内部状态
private String intrinsic;
//外部状态
protected final String Extrinsic;
//要求享元角色必须接受外部状态
public Flyweight(String _Extrinsic){
this.Extrinsic=_Extrinsic;
}
//定义业务操作
public abstract void operate();
//内部状态的getter/setter
public String getIntrinsic() {
return intrinsic;
}
public void setIntrinsic(String intrinsic) {
this.intrinsic = intrinsic;
}
}
具体享元角色:
具体的一个产品类,需要注意的是内部状态处理应该与环境无关,不应该出现一个操作改变了外部状态,同时也改变了内部状态。
public class ConcreteFlyweight extends Flyweight {
//接受外部状态
public ConcreteFlyweight(String _Extrinsic){
super(_Extrinsic);
}
//根据外部状态进行逻辑处理
@Override
public void operate() {
//业务逻辑
}
}
享元工厂:
构造一个池容器,提供从池中获得对象的方法。
public class FlyweightFactory {
//定义一个池容器
private static HashMap<String,Flyweight> pool=new HashMap<>();
//享元工厂
public static Flyweight getFlyweight(String Extrinsic){
//需要返回的对象
Flyweight flyweight=null;
//如果在池中有该对象,直接从池中拿
if (pool.containsKey(Extrinsic)){
flyweight=pool.get(Extrinsic);
}else { //如果池中没有该对象,则创建一个并放入池中
flyweight=new ConcreteFlyweight(Extrinsic);
pool.put(Extrinsic,flyweight);
}
return flyweight;
}
}
三享元模式的应用
1、优点
减少了应用程序创建的对象数量,降低内存的占用,增强了程序的性能。
2、缺点
增加了系统的复杂性,需要分离出外部状态和内部状态,并且外部状态具有固化属性,不应该随内部状态改变而改变。
3、使用场景
- 系统中存在大量的相似对象;
- 细粒度的对象都具备较接近的外部状态,而且内部状态与环境无关;
- 需要缓冲池的场景
四、JDK-Integer的应用源码分析
在Integer中的valueOf()
方法使用了享元模式,首先我们看一下以下代码的输出:
由以上运行结果可以看出x和y是同一个对象,我们具体看一下valueOf()
方法的源码实现:
//valueOf()方法的具体实现
public static Integer valueOf(int i) {
//IntegerCache.low=-128,IntegerCache.high=127
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
//Integer类中的静态方法,
static {
// high value may be configured by property
int h = 127;
String integerCacheHighPropValue =
sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
if (integerCacheHighPropValue != null) {
try {
int i = parseInt(integerCacheHighPropValue);
i = Math.max(i, 127);
// Maximum array size is Integer.MAX_VALUE
h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
} catch( NumberFormatException nfe) {
// If the property cannot be parsed into an int, ignore it.
}
}
high = h;
cache = new Integer[(high - low) + 1];
int j = low;
for(int k = 0; k < cache.length; k++)
cache[k] = new Integer(j++);
// range [-128, 127] must be interned (JLS7 5.1.7)
assert IntegerCache.high >= 127;
}
在上面的源代码我们可以看到,如果Integer.valueOf(int i)
中传递的i在[-128,127]之间,就会直接从IntegerCache.cache[i + (-IntegerCache.low)]
中取一个出来,如果不在这个范围,才会去创建一个新的Integer。