一、前言
享元模式即：Flyweight，它是对象池的一种实现。享元模式用来尽可能的减少内存的使用量。多用于存在大量重复对象的场景，或需要缓冲池的时候。用来缓存共享的对象。这样来避免内存移除等。
二、定义
运用共享技术有效的支持大量细粒度的对象。
三、例子
现在我们大概了解了什么是享元模式，概念再多不如一个简单例子来的痛快。下面我讲解一个查询巴士车票的例子来讲解什么是享元模式。
3.1、定义巴士车票
public interface Ticket {
public void showTicketInfo(String type);
}
public class BusTicket implements Ticket{
private static final String TAG = BusTicket.class.getSimpleName();
String from;
String to;
int price;
BusTicket(String from,String to) {
this.from = from;
this.to = to;
}
@Override
public void showTicketInfo(String type) {
price = new Random().nextInt(100);
Log.d(TAG,from + "到" + to + "的" + type + "巴士票价位" + price);
}
}
代码很简单根据from和to的地方来组成一张巴士车票。通过showTicketInfo可以打印车票价格信息。
3.2、工厂类辅助查询
我们先看这种写法：
public class TicketFactory {
public static Ticket getTicket(String from,String to) {
return new BusTicket(from,to);
}
}
比如当我们查询深圳到广州的巴士票的时候调用
Ticket ticket = TicketFactory.getTicket("shenzhen","guangzhou");
ticket.showTicketInfo("硬座");
看似没毛病，客户端这样调用查询就可以了。普通情况下这样确实没有问题，但当有大量客户同时查询的时候就可能会OOM了。因为我们会创建大量的相同对象，十分耗内存。当java的GC对这些对象回收的时候同样也属于资源浪费。这时候，该享元模式登场的时候了。我们只需要修改一下Factory。
public class TicketFactory {
static Map<String,Ticket> sTicketMap = new ConcurrentHashMap<String,Ticket>();
public static Ticket getTicket(String from,String to) {
String key = from + "-" + to;
if (sTicketMap.containsKey(key)) {
return sTicketMap.get(key);
} else {
Ticket ticket = new BusTicket(from,to);
sTicketMap.put(key,ticket);
return ticket;
}
}
}
这样用map来保存，以key查询，有重复就复用，没有就直接创建。避免了重复对象的创建。
四、JDK中的String
jdk中的String也是类似的消息池。一个String被定义过后就存在于常量池中。当其他地方使用相同的字符串时，实际使用的时缓存。
String str1 = new String("abc");
String str2 = new String("abc");
String str3 = "abc";
String str4 = "ab" + "c";
string一般我们用两个判断，
一个是equals，这个是比较内容，他们四个都相等。
另一个就是“==”判断。str1不等于str2，不等于str3。特别的，str3是等于str4。因为str1和str2是new的，str3是等号字面赋值。所以他们是不同的对象。而str4也是字面赋值。且str4使用了缓存在缓存池中的str3常量对象。所以用==判断的时候，他们是相同对象。
五、Message中的享元模式
关于Handler、Mesaage和Looper之间的关系这里不做详细讨论，有兴趣的同学可以看我另外一篇文章Android消息机制(Handler原理)-完全解析。这里我们只讲Message是如何使用享元模式。我们直接从发送message消息讲起，以下源码来自Android P。
5.1、handler发送message
public final boolean sendEmptyMessageAtTime(int what, long uptimeMillis) {
Message msg = Message.obtain();
msg.what = what;
return sendMessageAtTime(msg, uptimeMillis);
}
发送消息的时候最终调用sendEmptyMessageAtTime，通过Message.obtain();创建message并发送。享元模式就是从obtain这里切入。
5.2、Message.obtain
private static int sPoolSize = 0;
Message next;
private static final Object sPoolSync = new Object();
private static Message sPool;
public static Message obtain() {
synchronized (sPoolSync) {
if (sPool != null) {
Message m = sPool;
sPool = m.next;
m.next = null;
m.flags = 0; // clear in-use flag
sPoolSize--;
return m;
}
}
return new Message();
}
我们可以看到message要么是从最后new Message返回一个新的对象，要么返回sPool。当返回sPool时就是返回已创建的重复对象。再理解为啥sPool就是重复对象时，我们先看明白Message这个单链表对象。
5.3、Message是一个单链表对象
Message包含一个next的Message对象。sPoolSize表示个数，以此形成单链表结构。
单链表的取出
在obtain方法中
Message m = sPool ---m等于单链表
sPool = m.next ---sPool单链表舍弃表头元素
m.next = null; ---m舍弃除表头之外的所有元素
m.flags = 0; ---flag置0标记
sPoolSize--; ---单链表大小减1
这样就取出来了单链表的头元素并返回，而我们的单链表sPool舍弃表头。这样就完成了元素的复用。当然这里只是取出，接下来我们看插入
单链表的插入
插入的操作是在Message回收的时候
public void recycle() {
if (isInUse()) {
if (gCheckRecycle) {
throw new IllegalStateException("This message cannot be recycled because it "
+ "is still in use.");
}
return;
}
recycleUnchecked();
}
void recycleUnchecked() {
// Mark the message as in use while it remains in the recycled object pool.
// Clear out all other details.
flags = FLAG_IN_USE;
what = 0;
arg1 = 0;
arg2 = 0;
obj = null;
replyTo = null;
sendingUid = -1;
when = 0;
target = null;
callback = null;
data = null;
synchronized (sPoolSync) {
if (sPoolSize < MAX_POOL_SIZE) {
next = sPool;
sPool = this;
sPoolSize++;
}
}
}
recycle判断Message对象是否正在被使用，如果是则刨除异常，否则开始进行recycleUnchecked单链表插入操作。插入之前先清空了各个参数。重点在最后
synchronized (sPoolSync) {
if (sPoolSize < MAX_POOL_SIZE) {
next = sPool;
sPool = this;
sPoolSize++;
}
}
if (sPoolSize < MAX_POOL_SIZE) ---单链表大小还没超过MAX_POOL_SIZE则开始插入
next = sPool; ---next直接等于自身
sPool = this; ---sPool等于现在插入的元素
sPoolSize++; ---大小+1
就是一个普通单链表插入表头的操作。
5.4、Message享元模式小结
虽然Message并不是最标准的享元模式用法，但它通过单链表这种方式一样实现了对象池的思想。也是另一种妙用。由此笔者想多说一句就是设计模式并不是一成不变的，理解它的核心，多思考你才能融会贯通。
六、写在最后
享元模式实现起来还是比较简单。在需要大量重复对象的时候起到重要作用。也用作缓存池等场景。能够降低内存中对象的数量。
