花城人去今萧索，春梦绕胡沙。

——赵佶《眼儿媚》

设计模式-享元模式

1. 享元模式概述

1.1 享元模式是什么？

  1. 享元模式主要用于减少创建对象的数量，以减少内存占用和提高性能。这种类型的设计模式属于结构型模式，它提供了减少对象数量从而改善应用所需的对象结构的方式。

  2. 享元模式（Flyweight Pattern） 也叫 蝇量模式： 运用共享技术（共享对象的方式）有效地支持大量细粒度的对象。

    • 细粒度对象（可以理解为不使用线程池情况下的线程对象） : 是内存中的数量庞大的对象 ，实际使用的数量庞大的对象 ;
    • 共享对象（可以理解为线程池中的对象） :
      • 多个细粒度对象共享的部分数据 ;
      • 对象缓存池中存储的对象 ;
1.2 享元模式何时使用？
  1. 系统中有大量对象。
  2. 这些对象消耗大量内存。
  3. 这些对象的状态大部分可以外部化。
  4. 这些对象可以按照内蕴状态分为很多组，当把外蕴对象从对象中剔除出来时，每一组对象都可以用一个对象来代替。
  5. 系统不依赖于这些对象身份，这些对象是不可分辨的。
1.3 享元模式应用场景？
  1. 常用于系统底层开发，解决系统的性能问题。像数据库连接池，里面都是创建好的连接对象，在这些连接对象中有我们需要的则直接拿来用，避免重新创建，如果没有我们需要的，则创建一个 。
  2. 享元模式能够解决重复对象的内存浪费的问题，当系统中有大量相似对象，需要缓冲池时。不需总是创建新对象，可以从缓冲池里拿。这样可以降低系统内存，同时提高效率。
  3. 享元模式经典的应用场景就是池技术了，String 常量池、数据库连接池、缓冲池等等都是享元模式的应用，享元模式是池技术的重要实现方式。

2. 内部状态和外部状态

使用享元模式时，==注意划分内部状态和外部状态==：

  1. IntrinsicState内部状态 : 有些数据所有的对象都一样 , 显然不能当做对象一致性对比的依据 , 这就是内部状态 ;享元对象共享内部状态
  2. ExtrinsicState外部状态 : 有些数据每个对象都不一样 , 根据该数据确定对象的唯一性 , 相当于 哈希码 , 身份证号 , 档案编号 这一类的数据 , 这就是外部状态 ;每个享元对象的外部状态不同

3. 享元模式类图

  • Flyweight：享元对象–是产品的抽象类, 同时定义出对象的外部状态和内部状态（抽象类/接口）
  • ConcreteFlyWeight：是具体的享元角色，是具体的产品类，实现抽象角色定义相关业务。
  • FlyWeightFactory 享元工厂类，用于构建一个池容器(集合)， 同时提供从池中获取对象方法。
    • 从Client的角度去解释享元工厂类：使用对象时 , 先从对象池中获取对象 , 如果对象池中没有 , 创建一个 , 放入对象池 , 然后再从对象池中获取 。

4. 享元模式优缺点

优点
  1. 大大较少对象的创建，降低系统的内存，使效率提高。
缺点
  1. 系统的复杂度：
    • 需要分类出外部状态和内容状态也就是说将一个类拆解成多个类 ，而且外部状态具有固有化的性质，不应该随着内部状态的变化而变化，否则会造成系统的混乱。
    • 系统复杂性增加了 ，但是对客户端使用层面来说是简单的。

5. 享元模式在JDK源码中的应用

String中的体现

  1. Java的虚拟机会开辟一个内存区域（叫字符串缓冲池）来存储字符串常量，而通过new创建的字符串对象是存储在堆内存中。

  2. 当新建一个字符串常量时，首先会从字符串缓冲池中查找，如果找到则返回该常量的引用地址，如果找不到则新建一个字符串常量再返回地址引用。

  3. 当通过new新建一个字符串对象时，会在堆内存中开辟一个新建的空间，再初始化，即使两个字符串的值是一样的但它们的引用地址是不一样的，属于两个不同的对象。

1
2
3
4
5
6
7
8
9
10
11
public class FlyWeightString {
    public static void main(String[] args) {
        String s1 = "abc";
        String s2 = "abc";
        String s3 = new String("abc");
        String s4 = new String("abc");
        System.out.println(s1 == s2);//true
        System.out.println(s3 == s4);//false
        System.out.println(s1 == s3);//false
    }
}
Integer中的体现
  1. 如果 Integer.valueOf(x) ，x 在 -128 -127 直接就是使用享元模式返回，如果不在范围类，则仍然 new。
  2. 在valueOf 方法中，先判断值是否在 IntegerCache 中，如果不在，就创建新的Integer, 否则，就直接从缓存池返回。
  3. valueOf 方法，就使用到享元模式
  4. 如果使用valueOf 方法得到一个Integer 实例，范围在 -128 -127 ，执行速度比 new 快。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class FlyWeightInteger {

	public static void main(String[] args) {
		// 得到 x 实例，类型 Integer
		Integer x = Integer.valueOf(127);
		Integer y = new Integer(127);
		Integer z = Integer.valueOf(127);
		Integer w = new Integer(127);

		System.out.println(x == y ); //  false
		System.out.println(x == z ); // true
        
		System.out.println(w == x ); // false
		System.out.println(w == y ); // false


		Integer x1 = Integer.valueOf(200);
		Integer x2 = Integer.valueOf(200);
		System.out.println("x1==x2 :" + (x1 == x2)); // false
	}
}

Integer中的valueOf方法

1
2
3
4
5
6

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

Integer静态内部类IntegerCache

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
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() {}
}

☆