【源码分析设计模式 7】Integer中的享元模式

淩亂°似流年 2021-08-29 13:21 184阅读 0赞

## 一、基本概念 ##

说到享元模式，第一个想到的应该就是池技术了，String常量池、数据库连接池、缓冲池等等都是享元模式的应用，所以说享元模式是池技术的重要实现方式。

比如我们每次创建字符串对象时，都需要创建一个新的字符串对象的话，内存开销会很大，所以如果第一次创建了字符串对象“Flyweight”，下次再创建相同的字符串“Flyweight”时，只要把它的引用指向“Flyweight”，这样就实现了“Flyweight”字符串在内存中的共享。

举个最简单的例子，网络联机下棋的时候，一台服务器连接了多个客户端（玩家），如果我们每个棋子都要创建对象，那一盘棋可能就有上百个对象产生，玩家多点的话，因为内存空间有限，一台服务器就难以支持了，所以这里要使用享元模式，将棋子对象减少到几个实例。下面给出享元模式的定义。

## 二、享元模式的结构 ##

享元模式（ Flyweight），运用共享技术有效的支持大量细粒度的对象。UML结果图如下：

**![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70][]**

1、Flyweight 是抽象享元角色。它是产品的抽象类，同时定义出对象的外部状态和内部状态的接口和实现；

2、ConcreteFlyweight 是具体享元角色，是具体的产品类，实现抽象角色定义的业务；

3、UnsharedConcreteFlyweight 是不可共享的享元角色，一般不会出现在享元工厂中；

4、FlyweightFactory 是享元工厂，它用于构造一个池容器，同时提供从池中获得对象的方法。

## 三、内部状态和外部状态 ##

1、上面享元模式的定义为我们提出了两个要求：细粒度和共享对象。我们知道分配太多的对象列到应用程序中将有损程序的性能，同时还容易造成内存溢出，要避免这种情况，用到的就是享元模式，这里就需要提到内部状态和外部状态了。

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

2、内部状态指对象共享出来的信息，存储在享元对象内部并且不会随环境的改变而改变；

3、外部状态指对象得以依赖的一个标记，是随环境改变而改变的、不可共享的状态。  
我们举一个最简单的例子，棋牌类游戏大家都有玩过吧，比如说说围棋和跳棋，它们都有大量的棋子对象，围棋和五子棋只有黑白两色，跳棋颜色略多一点，但也是不太变化的，所以棋子颜色就是棋子的内部状态；而各个棋子之间的差别就是位置的不同，我们落子嘛，落子颜色是定的，但位置是变化的，所以方位坐标就是棋子的外部状态。

那么为什么这里要用享元模式呢？可以想象一下，上面提到的棋类游戏的例子，比如围棋，理论上有361个空位可以放棋子，常规情况下每盘棋都有可能有两三百个棋子对象产生，因为内存空间有限，一台服务器很难支持更多的玩家玩围棋游戏，如果用享元模式来处理棋子，那么棋子对象就可以减少到只有两个实例，这样就很好的解决了对象的开销问题。

## 四、享元模式的优缺点 ##

### 1、优点 ###

大大减少了对象的创建，降低了程序内存的占用，提高效率

### 2、缺点 ###

提高了系统的复杂度，需要分离出内部状态和外部状态，而外部状态具有固化特性，不应该随着内部状态的改变而改变。

## 五、享元模式的使用场景 ##

### 1、何时应用 ###

（1）系统中有大量对象时

（2）这些对象消耗大量内存时

（3）这些对象的状态大部分可以外部化时

（4） 需要缓冲池的场景

### 2、实现方式 ###

用唯一标识码判断，如果在内存中有，则返回这个唯一标识码所标识的对象，用hashmap存储。

### 3、应用实例 ###

（1）string常量池

（2）数据库连接池

## 六、代码实例 ##

应用实例的话，其实上面的模板就已经是一个很好的例子了，类似于String常量池，没有的对象创建后存在池中，若池中存在该对象则直接从池中取出。

为了更好的理解享元模式，这里再举一个实例，比如接了我一个小型的外包项目，是做一个产品展示网站，后来他的朋友们也希望做这样的网站，但要求都有些不同，我们当然不能直接复制粘贴再来一份，有任希望是新闻发布形式的，有人希望是博客形式的等等，而且因为经费原因不能每个网站租用一个空间。

其实这里他们需要的网站结构相似度很高，而且都不是高访问量网站，如果分成多个虚拟空间来处理，相当于一个相同网站的实例对象很多，这是造成服务器的大量资源浪费。如果整合到一个网站中，共享其相关的代码和数据，那么对于硬盘、内存、CPU、数据库空间等服务器资源都可以达成共享，减少服务器资源；而对于代码，由于是一份实例，维护和扩展都更加容易。

那么此时就可以用到享元模式了。UML图如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 1][]

### 1、网站抽象类 ###

package designMode.Flyweight.web2;
     
    public abstract class WebSite {
        public abstract void use();
    }

### 2、网站具体类 ###

package designMode.Flyweight.web2;
     
    public class ConcreteWebSite extends WebSite {
        private String name = "";
        public ConcreteWebSite(String name) {
            this.name = name;
        }
        @Override
        public void use() {
            System.out.println("网站分类：" + name);
        }
    }

### 3、网站工厂类 ###

package designMode.Flyweight.web2;
     
    import java.util.HashMap;
     
    public class WebSiteFactory {
        private HashMap<String, ConcreteWebSite> pool = new HashMap<>();
     
        //获得网站分类
        public WebSite getWebSiteCategory(String key) {
            if(!pool.containsKey(key)) {
                pool.put(key, new ConcreteWebSite(key));
            }
     
            return (WebSite)pool.get(key);
        }
     
        //获得网站分类总数
        public int getWebSiteCount() {
            return pool.size();
        }
    }

### 4、client客户端 ###

这里测试用例给了两种网站，原先我们需要做三个产品展示和三个博客的网站，也即需要六个网站类的实例，但其实它们本质上都是一样的代码，可以利用用户ID号的不同，来区分不同的用户，具体数据和模板可以不同，但代码核心和数据库却是共享的。

package designMode.Flyweight.web2;
     
    public class Client {
        public static void main(String[] args) {
            WebSiteFactory factory = new WebSiteFactory();
     
            WebSite fx = factory.getWebSiteCategory("产品展示");
            fx.use();
     
            WebSite fy = factory.getWebSiteCategory("产品展示");
            fy.use();
     
            WebSite fz = factory.getWebSiteCategory("产品展示");
            fz.use();
     
            WebSite fa = factory.getWebSiteCategory("博客");
            fa.use();
     
            WebSite fb = factory.getWebSiteCategory("博客");
            fb.use();
     
            WebSite fc = factory.getWebSiteCategory("博客");
            fc.use();
     
            System.out.println("网站分类总数为：" + factory.getWebSiteCount());
        }
    }

### 5、运行结果 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 2][]

可以看出，虽然我们做了6个网站，但网站分类只有2个。这样基本算是实现了享元模式的共享对象的目的，但想想上面提到的内部状态和外部状态，这里实际上没有体现对象间的不同，只体现了它们的共享部分。

### 6、用户类 ###

所以我们再加一个用户类，作为网站类的外部状态，并在use()方法中传递用户对象，UML如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 3][]

下面添加一个User类。

package designMode.Flyweight.web2;
     
    public class User {
        private String name;
        public User(String name){
            this.name = name;
        }
     
        public String getName(){
            return name;
        }
    }

然后再对use()方法进行修改，添加参数，以抽象类为例：

package designMode.Flyweight.web2;
     
    public abstract class WebSite {
        public abstract void use();
        public abstract void use(User user);
    }

而客户端中只需对每一个网站添加一个用户即可，如：

fx.use(new User("素小暖"));

运行结果如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 4][]

这样就可以协调内部与外部状态，哪怕接手了上千个网站的需求，只要要求相同或类似，实际开发代码也就是分类的哪几种。

## 七、Integer的享元模式解析 ##

### 1、测试类 ###

package designMode.advance.flyWeight;
    
    public class FlyWeight {
        public static void main(String[] args) {
            //如果 Integer.valueOf(x) x 在  -128 --- 127 直接，就是使用享元模式返回,如果不在
            //范围类，则仍然 new
    
            //小结:
            //1. 在valueOf 方法中，先判断值是否在 IntegerCache 中，如果不在，就创建新的Integer(new), 否则，就直接从 缓存池返回
            //2. valueOf 方法，就使用到享元模式
            //3. 如果使用valueOf 方法得到一个Integer 实例，范围在 -128 - 127 ，执行速度比 new 快
            
            Integer x = 127; // 得到 x实例，类型 Integer
            Integer y = new Integer(127); // 得到 y 实例，类型 Integer
            Integer z = Integer.valueOf(127);//..
            Integer w = new Integer(127);
    
            System.out.println(x.equals(y)); // 大小，true
            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
        }
    }

### 2、如果想了解怎么实现共享的，就得分析Integer的源代码 ###

Integer x = 127;和Integer z = Integer.valueOf(127);是一个意思；

下面我们来看下valueOf方法：

//意思就是 在一个区间之内，直接用IntegerCache.cache[]数组里面的数返回，否则new 一个新对象。
     public static Integer valueOf(int i) {
        assert IntegerCache.high >= 127;
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

再看一下IntegerCache类：

//是Integer内部的私有静态类,里面的cache[]就是jdk事先缓存的Integer。
    private static class IntegerCache {
        static final int low = -128;//区间的最低值
        static final int high;//区间的最高值，后面默认赋值为127，也可以用户手动设置虚拟机参数
        static final Integer cache[]; //缓存数组
    
        static {
            // high value may be configured by property
            int h = 127;
            //这里可以在运行时设置虚拟机参数来确定h  :-Djava.lang.Integer.IntegerCache.high=250
            String integerCacheHighPropValue =
                    sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            if (integerCacheHighPropValue != null) {//用户设置了
                int i = parseInt(integerCacheHighPropValue);
                i = Math.max(i, 127);//虽然设置了但是还是不能小于127
                // 也不能超过最大值
                h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
            }
            high = h;
    
            cache = new Integer[(high - low) + 1];
            int j = low;
            //循环将区间的数赋值给cache[]数组
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);
        }
    
        private IntegerCache() {}
    }

其实很简单，就是用一个Integer数组先缓存了，后面如果是是在区间内的数直接从缓存数组中取，否则才构造新的Integer。缓存思想还是很重要的！谢谢大家观看。

## 八、享元模式和单例模式的区别 ##

1、享元模式可以再次创建对象，也可以取缓存对象；单例模式则是严格控制单个进程中只有一个实例对象。

2、享元模式可以通过自己控制对外部的单例，也可以在需要时创建更多的对象；单例模式是自身控制，需要增加不属于该对象本身的逻辑。

两者都可以实现节省对象创建的时间， threadPool线程池、数据库连接池都有使用享元模式。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70]: /images/20210813/e0e4ac8b755e4b25b2b6ca011cf28658.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 1]: /images/20210813/7a3469956c7647349ff60392985c5f47.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 2]: /images/20210813/04b14c077ba2445e8f1f0a36ba2c2313.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 3]: /images/20210813/df4c9bc20ca9441b8305972d3bc795e0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 4]: /images/20210813/c6533295f9fb402d890ed315f292a017.png