设计模式-享元模式

1. 享元模式定义

   面向对象技术可以很好地解决一些灵活性或可扩展性问题，但在很多情况下需要在系统中增加类和 对象的个数。当对象数量太多时，将导致运行代价过高，带来性能下降等问题。享元模式正是为解决这 一类问题而诞生的。
   享元模式（Flyweight Pattern）又称为轻量级模式，是对象池的一种实现。类似于线程池，线程池可以避免不停的创建和销毁多个对象，消耗性能。提供了减少对象数量从而改善应用所需的对象结构的 方式。其宗旨是共享细粒度对象，将多个对同一对象的访问集中起来，不必为每个访问者创建一个单独 的对象，以此来降低内存的消耗，属于结构型模式。

原文：Use sharing to support large numbers of fine-grained objects efficiently.
解释：使用共享对象可有效地支持大量的细粒度的对象

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

享元模式通用UML类图：

享元模式有三个参与角色：

• 抽象享元角色（Flyweight）

享元对象抽象基类或者接口，同时定义出对象的外部状态和内部状态 的接口或实现；

• 具体享元角色（ConcreteFlyweight）

实现抽象角色定义的业务。该角色的内部状态处理应该与 环境无关，不能出现会有一个操作改变内部状态，同时修改了外部状态；

• 享元工厂（FlyweightFactory）

负责管理享元对象池和创建享元对象。

2. 享元模式应用场景

   当系统中多处需要同一组信息时，可以把这些信息封装到一个对象中，然后对该对象进行缓存，这 样，一个对象就可以提供给多处需要使用的地方，避免大量同一对象的多次创建，消耗大量内存空间。 享元模式其实就是工厂模式的一个改进机制，享元模式 同样要求创建一个或一组对象，并且就是通 过工厂方法生成对象的，只不过享元模式中为工厂方法增加了缓存这一功能。主要总结为以下应用场景：
1、常常应用于系统底层的开发，以便解决系统的性能问题。
2、系统有大量相似对象、需要缓冲池的场景。
3 、在生活中的享元模式也很常见，比如各中介机构的房源共享，再比如全国社保联网。

3. 代码示例

• 使用享元模式实现共享池业务
  我们每年春节为了抢到一张回家的火车票都要大费周折，进而出现了很多刷票 软件，刷票软件会将我们填写的信息缓存起来，然后定时检查余票信息。抢票的时候，我们肯定是要查 询下有没有我们需要的票信息，这里我们假设一张火车的信息包含：出发站，目的站，价格，座位类别。 现在要求编写一个查询火车票查询伪代码，可以通过出发站，目的站查到相关票的信息。 比如要求通过出发站，目的站查询火车票的相关信息，那么我们只需构建出火车票类对象，然后提 供一个查询出发站，目的站的接口给到客户进行查询即可，具体代码如下，创建 ITicket 接口：

public interface ITicket { void showInfo(String bunk); }

public class TrainTicket implements ITicket { 
	private String from; 
	private String to; 
	private int price; 
	public TrainTicket(String from, String to) { this.from = from; this.to = to; }
	public void showInfo(String bunk) { 
		this.price = new Random().nextInt(500); 
		System.out.println(String.format("%s->%s：%s 价格：%s 元", this.from, this.to, bunk, this.price)); 
		}
	}
}

public static class TicketFactory {
	public static ITicket queryTicket(String from, String to) { 
		return new TrainTicket(from, to); 
	} 
}

编写客户端代码：

public static void main(String[] args) { 
	ITicket ticket = TicketFactory.queryTicket("深圳北", "潮汕"); 
	ticket.showInfo("硬座"); 
}

  分析上面的代码，我们发现客户端进行查询时，系统通过 TicketFactory 直接创建一个火车票对象， 但是这样做的话，当某个瞬间如果有大量的用户请求同一张票的信息时，系统就会创建出大量该火车票 对象，系统内存压力骤增。而其实更好的做法应该是缓存该票对象，然后复用提供给其他查询请求，这 样一个对象就足以支撑数以千计的查询请求，对内存完全无压力，使用享元模式可以很好地解决这个问 题。我们继续优化代码，只需在 TicketFactory 类中进行更改，增加缓存机制：

package com.gupaoedu.vip.pattern.flyweight.ticket;

/**
 * 抽象的享元角色，时所有的具体享元类的基类，为具体享元规范需要实现的公共接口
 * 非享元的外部状态以参数的形式通过方法传入。
 */
public interface ITicket {
    // 显示票的信息，通过传递的参数bunk 来区分不同的票
    void showInfo(String bunk);
}

然后，创建 具体的享元角色：TrainTicket类，实现ITicket 接口

package com.gupaoedu.vip.pattern.flyweight.ticket;

import java.security.SecureRandom;

/**
 * 具体享元角色；实现抽象享元角色中规定的接口
 */
public class TrainTicket implements ITicket {
    // 票的出发地
    private String from;
    // 票的目的地
    private String to;
    // 票的价格
    private int price;

    // 出发地和目的地为外部输入,是外部状态
    public TrainTicket(String from, String to) {
        this.from = from;
        this.to = to;
    }

    /**
     * 外部状态
     * @param bunk 座位席别
     */
    public void showInfo(String bunk) {
        // 票价属于由系统内部生成 ，这里用随机数模拟
        this.price = new SecureRandom().nextInt(500);
        // 票的具体信息
        System.out.println(String.format("%s -> %s  %s价格：%s 元", from, to, bunk, price));
    }
}

最后创建享元工厂 TicketFactory 类：

package com.gupaoedu.vip.pattern.flyweight.general;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 享元工厂
 * 初始化时会预先创建一部分对象缓存起来，使用享元对象时从缓存中去取，用完之后，享元对象归还到缓存中，而不是被GC
 */
public class FlyweightFactory {
    private static Map<String,IFlyweight>  pool = new ConcurrentHashMap<>();
    // 因为内部状态具备不变性，因此可以作为缓存的key
    public static IFlyweight getFlyweight(String intrinsicState){
        if(!pool.containsKey(intrinsicState)){
            IFlyweight flyweight = new ConcreteFlyweight(intrinsicState);
            pool.put(intrinsicState, flyweight);
        }
        return pool.get(intrinsicState);
    }
}

测试：

package com.gupaoedu.vip.pattern.flyweight.ticket;

public class TicketTest {
    public static void main(String[] args) {
        ITicket ticket = TicketFactory.queryTicket("北京", "南京南");
        ticket.showInfo("硬座");
        ticket = TicketFactory.queryTicket("北京", "南京南");
        // 再次查询，北京-南京南已经有产生ITicket的实例了，直接从缓存中获取，只是由于座位席别不同，价格也不同了
        ticket.showInfo("硬卧");
        ticket = TicketFactory.queryTicket("北京西", "南京南");
        ticket.showInfo("硬卧");
    }
}

可以看到，除了第一次查询创建对象后，后续查询相同车次票信息都是使用缓存对象，无需创建新 对象了。来看一下类结构图：

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

• Integer 中的享元模式

package com.gupaoedu.vip.pattern.flyweight;
public class IntegerTest {
    public static void main(String[] args) {

        Integer a = Integer.valueOf(100);
        Integer b = 100;

        Integer c = Integer.valueOf(128);
        Integer d = 128;

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

结果很让人意外：

之所以得到这样的结果，是因为 Integer 用到的享元模式，Integer有一个内部类IntegerCache，将-128~127之间的数缓存到了一个数组中，
使用时通过运算获取数组下标直接取出要使用的数，此范围之外的，返回一个 new Integer(i)，因此上面的c和d是不同的对象；源码如下：

public final class Integer extends Number implements Comparable<Integer> {
    public static Integer valueOf(int var0) {
        return var0 >= -128 && var0 <= Integer.IntegerCache.high ? Integer.IntegerCache.cache[var0 + 128] : new Integer(var0);
    }
    //...省略...
}

    //是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() {}
    }

类似的，在Long中也使用了享元模式，不过不能指定缓存最大值：

public final class Long extends Number implements Comparable<Long> {
    public static Long valueOf(long var0) {
        return var0 >= -128L && var0 <= 127L ? Long.LongCache.cache[(int)var0 + 128] : new Long(var0);
    }   
    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);
        }
    }
    //...
}

• String中的享元模式

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 存在字符串常量池，new String(“lo”)存在堆中，String s4 = “hel” + new String(“lo”)实质上是两个对象的相加，编译器不会进 行优化，相加的结果存在堆中，而 s1 存在字符串常量池中，当然不相等。

s1== s9 的原理一样。 s4==s5 两个相加的结果都在堆中，肯定不相等。

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

• 享元模式在Apache Commons Pool2中的使用
  对象池化的基本思路是：将用过的对象保存起来，等下一次需要这种对象的时候，再拿出来重复使用，从而在一定程度上减少频繁创建对象所造成的开销。用于充当保存对象的“容器”的对象，被称为“对象池”（Object Pool，或简称Pool）

Apache Commons Pool实现了对象池的功能。定义了对象的生成、销毁、激活、钝化等操作及其状态转换，并提供几个默认的对象池实现。几个重要的对象：

PooledObject（池对象）：用于封装对象（如：线程、数据库连接、TCP连接），将其包裹成可被池管理的对象。
PooledObjectFactory（池对象工厂）：定义了操作PooledObject实例生命周期的一些方法，PooledObjectFactory必须实现线程安全。
Object Pool （对象池）：Object Pool负责管理PooledObject，如：借出对象，返回对象，校验对象，有多少激活对象，有多少空闲对象。

 // 对象池
 private final Map<S, PooledObject<S>> allObjects = new ConcurrentHashMap<S, PooledObject<S>>();

重要方法：
borrowObject：从池中借出一个对象。
returnObject：将一个对象返还给池。

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

享元模式的定义为我们提出了两个要求：细粒度和共享对象。因为要求细粒度对象，所以不可避免 地会使对象数量多且性质相近，此时我们就将这些对象的信息分为两个部分：内部状态和外部状态。
内部状态指对象共享出来的信息，存储在享元对象内部并且不会随环境的改变而改变；
外部状态指 对象得以依赖的一个标记，是随环境改变而改变的、不可共享的状态。 比如，连接池中的连接对象，保存在连接对象中的用户名、密码、连接 url 等信息，在创建对象的 时候就设置好了，不会随环境的改变而改变，这些为内部状态。而每个连接要回收利用时，我们需要给 它标记为可用状态，这些为外部状态。

6. 享元模式的优缺点

优点:
1、减少对象的创建，降低内存中对象的数量，降低系统的内存，提高效率;
2、减少内存之外的其他资源占用。
缺点：
1、关注内、外部状态、关注线程安全问题；
2、使系统、程序的逻辑复杂化