小侃设计模式（十一）-享元模式

1.概述

享元模式（Flyweight Pattern）也叫蝇量模式，它是运用共享技术有效地支持大量细粒度的对象，解决重复对象浪费内存的问题。它常用于系统底层的开发，解决系统的性能问题。比如数据库连接池，这里面都是已经创建好的连接对象，需要时直接拿来使用，避免重复创建。享元模式最经典的使用场景就是池技术了，String常量池、数据库连接池等、缓冲池等都是享元模式的使用。本文将介绍享元模式的原理及使用方式。

2.原理及使用

2.1 原理

享元模式的类图如下所示：

类图中主要包含四个核心角色：

抽象的享元角色（FlyWeight）: 它是产品的抽象类，同时定义出对象的内部状态（不会随着环境的改变而改变的可共享部分）和外部状态（随环境改变而改变的不可以共享的部分）；
具体的享元角色（ConcreteFlyWeight）:是具体的产品类，实现抽象角色定义的相关业务；
不可共享角色（UnsharedConcreteFlyWeight）: 不能被共享的子类可设计成不可共享角色；
享元工厂类（FlyweightFactory）:负责创建和管理享元角色，当使用者创建享元对象时，会由享元工厂先从工厂中获取，若存在则对外提供，不存在则由工厂创建。

2.2 案例

如果要开发一个在线斗地主游戏，已知一副牌有54张，如果每张牌都是一个单独的对象，也就是一桌需要存储54个对象，如果有1000、10000、1000000桌的话，需要存储的对象分别是100054，1000054，1000000*54，很明显这不合理。

通过享元模式来设计上述场景，如下：

抽象的享元角色就是Poker，它的内部分别包含了两个抽象方法，发牌方法push()和获取当前牌的状态；
享元角色就是ConcretePoker，它的内部有两个属性：牌的数字（number）和花色（color），分别有两个方法getNumber()、getColor()来获取当前牌的数字和花色；
不可共享角色就是UnsharedConcretePoker，内部有一个属性status（当前牌的状态：已出、未出），可能还存储张牌的用户信息userId等这些不可共享角色；
享元工厂就是PokerFactory，内部有一个pokers数组，用来存储享元角色ConcretePoker。
这样划分的好处是：整个系统内存中只存储了54张牌的信息，即使参与的人数再多，变更的也只是不可共享角色部分，极大地节约了内存资源。

编码如下：

public abstract class Poker {

    abstract void push();

    abstract boolean getStatus();
}


public class ConcretePoker extends Poker {

    public ConcretePoker(String number, String color) {
        this.number = number;
        this.color = color;
    }

    private String number;

    private String color;

    public String getNumber() {
        return number;
    }

    public String getColor() {
        return color;
    }

    @Override
    public String toString() {
        return "ConcretePoker{" +
                "number='" + number + '\'' +
                ", color='" + color + '\'' +
                '}';
    }

    @Override
    void push() {
        throw new UnsupportedOperationException();
    }

    @Override
    boolean getStatus() {
        throw new UnsupportedOperationException();
    }
}

public class UnsharedConcretePoker extends Poker {

    public UnsharedConcretePoker(Long userId) {
        this.userId = userId;
    }

    private Boolean status;

    private Long userId;

    public Long getUserId() {
        return userId;
    }

    public void setUserId(Long userId) {
        this.userId = userId;
    }

    public void setStatus(boolean status) {
        this.status = status;
    }

    @Override
    void push() {
        System.out.println("牌已经被打出");
        setStatus(true);
    }

    @Override
    boolean getStatus() {
        System.out.println("牌的状态是：" + status);
        return status;
    }
}


public class PokerFactory {

    private HashMap<String, ConcretePoker> pokers = new HashMap<>();


    private void addPoker(ConcretePoker poker) {
        //以牌的number+":"+color来做key
        String key = poker.getNumber() + ":" + poker.getColor();
        pokers.put(key, poker);
        System.out.println("添加牌：" + poker.toString() + "成功");
    }

    public ConcretePoker getPoker(String key) {
        ConcretePoker concretePoker = pokers.get(key);
        //双重验证，多线程安全
        if (concretePoker == null) {
            synchronized (PokerFactory.class) {
                ConcretePoker concretePoker1 = pokers.get(key);
                if (concretePoker1 == null) {
                    //创建ConcretePoker对象放入列表
                    String[] split = key.split(":");
                    ConcretePoker concretePoker2 = new ConcretePoker(split[0], split[1]);
                    pokers.put(key, concretePoker2);
                    System.out.println("工厂添加牌：" + concretePoker2.toString() + "成功");
                    return concretePoker2;
                }
            }
        } else {
            System.out.println("工厂已存在牌：" + concretePoker.toString());
        }
        return concretePoker;
    }
}

//测试类
public class Test {
    public static void main(String[] args) {
        String[] strings = new String[]{"A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "Small", "Big"};
        PokerFactory pokerFactory = new PokerFactory();

        //Hearts：红桃，Spades：黑桃，Diamond：方片，Clubs：梅花
        String[] colors = new String[]{"Hearts", "Spades", "Diamond", "Clubs"};
        Random random = new Random();
        for (int i = 0; i < 20; i++) {
            int index = random.nextInt(strings.length);
            String number = strings[index];
            if (!number.equals("Small") && !number.equals("Big")) {
                int colorIndex = random.nextInt(colors.length);
                String color = colors[colorIndex];
                String key = number + ":" + color;
                ConcretePoker poker = pokerFactory.getPoker(key);
            } else {
                if (number.equals("Small")) {
                    String key = "Small:King";
                    ConcretePoker poker = pokerFactory.getPoker(key);
                } else {
                    String key = "Big:King";
                    ConcretePoker poker = pokerFactory.getPoker(key);
                }
            }
        }
    }
}

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

运行结果如下：

2.3 享元模式的应用

享元模式在各种池的场景中使用较多，这里以Integer常量池为例，当值处于-128到127时，会从缓存池中获取，否则会生成新的对象指向所创建对象的地址。

3.小结

1.享元模式大大地减少了对象地创建，降低了程序内存的应用，提高了效率；
2.使用享元模式时，需要注意划分内部状态和外部状态，并且需要一个工厂类加以控制；
3.享元模式的使用场景是系统中存在大量对象，且这些对象消耗大量内存，这些对象的状态大部分可以外部化；
4.享元模式提高了系统的复杂度。需要分离出内部状态和外部状态，而外部状态具有固化特性，不应该随着内部状态的改变而改变。

4.参考文献

1.《设计模式-可复用面向对象软件的基础》-Erich Gamma、Richard Helm、Ralph Johnson、John Vlissides
2.《可复用物联网Web3D框架的设计与实现》-程亮（知网）
3.https://www.bilibili.com/video/BV1G4411c7N4-尚硅谷设计模式
4.https://zhuanlan.zhihu.com/p/74872012