【大话设计模式】模式二十：享元模式在多种池子中的应用

【引入】

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

一、享元模式

享元模式（Flyweight），运用共享技术有效地支持大量细粒度的对象。[DP]

 

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

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

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

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

 通用代码

享元类超类

public abstract class Flyweight {
    public abstract void operation(int extrinsicState);
}

 共享类

public class ConcreteFlyweight extends Flyweight {
    @Override
    public void operation(int extrinsicState) {
        System.out.println("具体FLyweight：" + extrinsicState);
    }
}

非共享类

public class UnsharedConcreteFlyweight extends Flyweight {
    @Override
    public void operation(int extrinsicState) {
        System.out.println("不共享的具体Flyweight:" + extrinsicState);
    }
}

 享元工厂类

public class FlyweightFactory {
    private Hashtable flyweights = new Hashtable();

    public FlyweightFactory() {
        flyweights.put("X", new ConcreteFlyweight());
        flyweights.put("Y", new ConcreteFlyweight());
        flyweights.put("Z", new ConcreteFlyweight());
    }

    public Flyweight getFlyweight(String key) {
        return ((Flyweight) flyweights.get(key));
    }
}

客户端

public class Demo {
    public static void main(String[] args) {
        int extrinsicState=22;
        FlyweightFactory factory=new FlyweightFactory();

        Flyweight flyweight1=factory.getFlyweight("X");
        flyweight1.operation(--extrinsicState);

        Flyweight flyweight2= factory.getFlyweight("Y");
        flyweight2.operation(--extrinsicState);

        Flyweight flyweight3=factory.getFlyweight("Z");
        flyweight3.operation(--extrinsicState);

        Flyweight unShared=new UnsharedConcreteFlyweight();
        unShared.operation(--extrinsicState);
    }
}

 【运行结果】

---

二、应用举例

创建网站的例子，有许许多多个人博客和陈列网页，利用享元模式，可以节省内存空间。

UML类图设计：

 扩展

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

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

 用户类

public class User {
    private String name;

    public User(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

网站类

public abstract class Website {
    public abstract void use(User user);
}

 具体网站

public class ConcreteWebsite extends Website {
    private String name = "";

    public ConcreteWebsite(String name) {
        this.name = name;
    }

    @Override
    public void use(User user) {
        System.out.println("网站分类：" + name + " 用户" + user.getName());
    }
}

网站工厂

public class WebsiteFactory {
    private Hashtable flyweights = new Hashtable();

    //获得网站分类
    public Website getWebsiteCategory(String key) {
        if (!flyweights.contains(key)) {
            flyweights.put(key, new ConcreteWebsite(key));
        }
        return ((Website) flyweights.get(key));
    }

    //获得网站分类数
    public int getWebsiteCount() {
        return flyweights.size();
    }
}

 客户端类

public class Demo {
    public static void main(String[] args) {
        WebsiteFactory factory = new WebsiteFactory();

        Website website1 = factory.getWebsiteCategory("产品展示");
        website1.use(new User("小明"));

        Website website2 = factory.getWebsiteCategory("产品展示");
        website2.use(new User("玉皇大帝"));

        Website website3 = factory.getWebsiteCategory("博客");
        website3.use(new User("太上老君"));

        Website website4 = factory.getWebsiteCategory("博客");
        website4.use(new User("海绵宝宝"));

        System.out.println("网站分类总数："+factory.getWebsiteCount());
    }
}

【运行结果】

---

三、模式总结

1、模式优点
大大减少对象创建，节省内存空间和资源

2、模式缺点
为了使对象可以共享，需要将一些不能共享的状态外部化，这将增加程序的复杂性。
读取享元模式的外部状态会使得运行时间稍微变长。

3、何时应用

在以下情况下可以使用享元模式：

• 一个系统有大量相同或者相似的对象，由于这类对象的大量使用，造成内存的大量耗费；
• 对象的大部分状态都可以外部化，可以将这些外部状态传入对象中(细粒度对象)；
• 使用享元模式需要维护一个存储享元对象的享元池，而这需要耗费资源，因此，应当在多次重复使用享元对象时才值得使用享元模式。

---

 四、源码中模式的应用

 1、字符常量池
很多语言的引擎为了减少字符串对象的重复创建，会在内存中维护有一个特殊的内存，这个内存就叫字符常量池。当创建新的字符串时，引擎会对这个字符串进行检查，与字符常量池中已有的字符串进行比对，如果存在有相同内容的字符串，就直接将引用返回，否则在字符常量池中创建新的字符常量，并返回引用。

2、 缓存机制
根据二八原则，80% 的请求其实访问的是 20% 的资源，我们可以将频繁访问的资源缓存起来，如果用户访问被缓存起来的资源就直接返回缓存的版本，这就是 Web 开发中经常遇到的缓存。

缓存服务器就是缓存的最常见应用之一，也是复用资源的一种常用手段。缓存服务器的示意图如下：

缓存服务器位于访问者与业务服务器之间，对业务服务器来说，减轻了压力，减小了负载，提高了数据查询的性能。对用户来说，提升了网页打开速度，优化了体验。

缓存技术用的非常多，不仅仅用在缓存服务器上，浏览器本地也有缓存，查询的 DNS 也有缓存，包括我们的电脑 CPU 上，也有缓存硬件。

3、线程池

以 Node.js 中的线程池为例，Node.js 的 JavaScript 引擎是执行在单线程中的，启动的时候会新建 4 个线程放到线程池中，当遇到一些异步 I/O 操作（比如文件异步读写、DNS 查询等）或者一些 CPU 密集的操作（Crypto、Zlib 模块等）的时候，会在线程池中拿出一个线程去执行。如果有需要，线程池会按需创建新的线程。

线程池在整个 Node.js 事件循环中的位置可以参照下图：

上面这个图就是 Node.js 的事件循环（Event Loop）机制，简单解读一下（扩展视野，不一定需要懂）：

所有任务都在主线程上执行，形成执行栈（Execution Context Stack）；

主线程之外维护一个任务队列（Task Queue），接到请求时将请求作为一个任务放入这个队列中，然后继续接收其他请求；

一旦执行栈中的任务执行完毕，主线程空闲时，主线程读取任务队列中的任务，检查队列中是否有要处理的事件，这时要分两种情况：如果是非 I/O 任务，就亲自处理，并通过回调函数返回到上层调用；如果是 I/O 任务，将传入的参数和回调函数封装成请求对象，并将这个请求对象推入线程池等待执行，主线程则读取下一个任务队列的任务，以此类推处理完任务队列中的任务；

线程池当线程可用时，取出请求对象执行 I/O 操作，任务完成以后归还线程，并把这个完成的事件放到任务队列的尾部，等待事件循环，当主线程再次循环到该事件时，就直接处理并返回给上层调用；

 参考资料：《深入浅出 Nodejs》

---

如果文章对你有用的话，三连支持一下吧！！！