设计模式之享元模式

享元模式

享元模式

面向对象技术可以很好地解决一些灵活性或可扩展性问题，但在很多情况下需要在系统中增加类和对象的个数。当对象数量太多时，将导致运行代价过高，带来性能下降等问题。享元模式正是为解决这一类问题而诞生的。

享元模式（Flyweight Pattern）又称为轻量级模式，是对象池的一种实现。类似于线程池，线程池可以避免不停的创建和销毁多个对象，消耗性能，提供了减少对象数量从而改善应用所需的对象结构的方式。其宗旨是共享细粒度对象，将多个对同一对象的访问集中起来，不必为每个访问者创建一个单独的对象，以此来降低内存的消耗，属于结构型模式。

享元模式把一个对象的状态分成内部状态和外部状态，内部状态即是不变的，外部状态是变化的；然后通过共享不变的部分，达到减少对象数量并节约内存的目的，享元模式模式的本质是缓存共享对象，降低内存消耗。

通用UML类图如下

从类图上看，享元模式有三个参与角色：
抽象享元角色（IFlyweight）：享元对象抽象基类或者接口，同时定义出对象的外部状态和内部状态的接口或实现；
具体享元角色（ConcreteFlyweight）：实现抽象角色定义的业务。该角色的内部状态处理应该与环境无关，不能出现会有一个操作改变内部状态，同时修改了外部状态；
享元工厂（FlyweightFactory）：负责管理享元对象池和创建享元对象。

通用代码

抽象享元角色（IFlyweight）

public interface IFlyweight
{
    void operation(String str);

    void showInfo(String str);
}

具体享元角色（ConcreteFlyweight）

public class ConcreteFlyweight implements IFlyweight
{

	// 内部不可变信息
	private String info;

	// 可变信息
	private String other;

	public ConcreteFlyweight(String info)
	{
		this.info = info;
	}

	@Override
	public void operation(String str)
	{
		this.other = "Flyweight " + str;
		System.out.println("set other");
	}

	@Override
	public void showInfo(String str)
	{
		System.out.println(other + " " + info + " " + str);
	}
}

享元工厂（FlyweightFactory）

public class FlyweightFactory
{
	private static Map<String, IFlyweight> flyweightMap = new HashMap<>();

	static
	{
		flyweightMap.put("flyWeight", new ConcreteFlyweight("不可变信息"));
	}

	public static IFlyweight getFlyweight(String str)
	{
		return flyweightMap.get(str);
	}
}

测试代码

public class Main
{

	public static void main(String[] args)
	{
		IFlyweight flyweight = FlyweightFactory.getFlyweight("flyWeight");
		if(flyweight != null)
		{
			flyweight.operation("test");
			flyweight.showInfo("info");
		}
	}
}

输出结果

set other
Flyweight test 不可变信息 info

享元模式的内部状态和外部状态

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

内部状态指对象共享出来的信息，存储在享元对象内部并且不会随环境的改变而改变；外部状态指对象得以依赖的一个标记，是随环境改变而改变的、不可共享的状态。

比如，连接池中的连接对象，保存在连接对象中的用户名、密码、连接url等信息，在创建对象的时候就设置好了，不会随环境的改变而改变，这些为内部状态。而每个连接要回收利用时，我们需要给它标记为可用状态，这些为外部状态。

应用场景

当系统中多处需要同一组信息时，可以把这些信息封装到一个对象中，然后对该对象进行缓存，这样，一个对象就可以提供给多处需要使用的地方，避免大量同一对象的多次创建，消耗大量内存空间。

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

主要总结为以下应用场景：

1、常常应用于系统底层的开发，以便解决系统的性能问题。

2、系统有大量相似对象、需要缓冲池的场景。

享元模式在源码中的应用

String中的享元模式

Java中将String类定义为final（不可改变的），JVM中字符串一般保存在字符串常量池中，java会确保一个字符串在常量池中只有一个拷贝，这个字符串常量池在JDK6.0以前是位于常量池中，位于永久代，而在JDK7.0中，JVM将其从永久代拿出来放置于堆中。

示例

public static void main(String[] args)
{
	String s1 = "hello";
	String s2 = "hello";
	String s3 = "he" + "llo";
	String s4 = "hel" + new String("lo");
	String s5 = new String("hello");
	String s6 = s5.intern();
	String s7 = "h";
	String s8 = "ello";
	String s9 = s7 + s8;
	System.out.println(s1 == s2);//true
	System.out.println(s1 == s3);//true
	System.out.println(s1 == s4);//false
	System.out.println(s1 == s9);//false
	System.out.println(s4 == s5);//false
	System.out.println(s1 == s6);//true
}

String类的final修饰的，以字面量的形式创建String变量时，JVM会在编译期间就把该字面量 “hello”放到字符串常量池中，由Java程序启动的时候就已经加载到内存中了。这个字符串常量池的特点就是有且只有一份相同的字面量，如果有其它相同的字面量，JVM则返回这个字面量的引用，如果没有相同的字面量，则在字符串常量池创建这个字面量并返回它的引用。

由于s2指向的字面量”hello”在常量池中已经存在了（s1先于s2），于是JVM就返回这个字面量绑定的引用，所以s1==s2。

s3中字面量的拼接其实就是”hello”，JVM在编译期间就已经对它进行优化，所以s1和s3也是相等的。

s4中的new String（”lo”）生成了两个对象，lo，new String（”lo”），lo存在字符串常量池，newString（”lo”）存在堆中，String s4=”hel”+new String（”lo”）实质上是两个对象的相加，编译器不会进行优化，相加的结果存在堆中，而s1存在字符串常量池中，当然不相等。s1==s9的原理一样。

s4==s5 两个相加的结果都在堆中，肯定不相等。

s1==s6中，s5.intern（方法能使一个位于堆中的字符串在运行期间动态地加入到字符串常量池中（字符串常量池的内容是程序启动的时候就已经加载好了），如果字符串常量池中有该对象对应的字面量，则返回该字面量在字符串常量池中的引用，否则，创建复制一份该字面量到字符串常量池并返回它的引用。因此s1==s6输出true。

Integer中的享元模式

对象Integer，也用到了享元模式。

示例

public static void main(String[] args)
{
	Integer a = Integer.valueOf(100);
	Integer b = 100;
	Integer c = Integer.valueOf(1000);
	Integer d = 1000;

	System.out.println("a==b:" + (a == b));  // a==b:true
	System.out.println("c==d:" + (c == d));  // c==d:false
}

Integer用到的享元模式，所以a==b 为 true

相关源码

public final class Integer extends Number implements Comparable<Integer> {
...
      private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];

        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;
        }

        private IntegerCache() {}
    }
...  
    public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }
...
}

Integer源码中的valueOf()方法做了一个条件判断，如果目标值在-128到127之间，则直接从缓存中取值，否则新建对象。那JDK为何要这样做呢？因为在-128到127之间的数据在int范围内是使用最频繁的，为了节省频繁创建对象带来的内存消耗，这里就用到了享元模式，来提高性能。Integer可以通过 JVM 参数 java.lang.Integer.IntegerCache.high 来设置缓存的最大值。

Long中的享元模式

public final class Long extends Number implements Comparable<Long> {
...
    private static class LongCache {
        private LongCache(){}

        static final Long cache[] = new Long[-(-128) + 127 + 1];

        static {
            for(int i = 0; i < cache.length; i++)
                cache[i] = new Long(i - 128);
        }
    }

    public static Long valueOf(long l) {
        final int offset = 128;
        if (l >= -128 && l <= 127) { // will cache
            return LongCache.cache[(int)l + offset];
        }
        return new Long(l);
    }
...
}

同理，Long中也有缓存，不过不能指定缓存最大值。

享元模式的优缺点

优点：

1、减少对象的创建，降低内存中对象的数量，降低系统的内存，提高效率。

2、减少内存之外的其他资源占用。

缺点：

1、关注内、外部状态、关注线程安全问题。

2、使系统、程序的逻辑复杂化。

打赏