设计模式：享元模式_设计单链表的享元模式-CSDN博客

本文链接：https://blog.csdn.net/weixin_42277946/article/details/130131446

一、定义：

使用享元对象有效地支持大量的细粒度对象。

二、角色

Flyweight：抽象的享元角色，是产品的抽象类，同时定义出对象的外部状态和内部状态的接口或实现。
ConcreteFlyweight：具体的享元角色，是具体的产品类，实现抽象角色，定义相关业务。
UnsharedConcreteFlyweight：不可共享的角色，一般不会出现在享元工厂。
FlyweightFactory：享元工厂类，用于构建一个池容器(集合)，同时提供从池中获取对象的方法。

三、使用场景

系统中存在大量的相似对象
细粒度的对象都具备较接近的外部状态，并且内部状态和环境无关，也就是对象没有特定身份
需要缓冲池的场景

四、案例代码

/**
 * 享元对象抽象基类
 */
interface Book {
    void readBook();
}

/**
 * 具体的享元对象
 */
class ConcreteBook implements Book {
    private String name;

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

    @Override
    public void readBook() {
        System.out.println("当前正在阅读:" + name);

    }
}

/**
 * 定义享元工厂 -- 图书工厂
 */
class BookFactory {
    private static Map<String, Book> bookMaps = new HashMap<>();

    public static ConcreteBook getBook(String name) {
        if (bookMaps.containsKey(name)) {
            System.out.println("有该书籍，直接找到");
            return (ConcreteBook) bookMaps.get(name);
        } else {
            System.out.println("没有该书籍,去买一本，重新创建");
            ConcreteBook book = new ConcreteBook(name);
            bookMaps.put(name, book);
            return book;
        }
    }
}

//客户端
public class Client {
    public static void main(String[] args) {
        ConcreteBook book1 = BookFactory.getBook("三国演义");
        book1.readBook();
        ConcreteBook book2 = BookFactory.getBook("三国演义");
        book2.readBook();
    }
}

五、在Android中的使用

Android Handler消息机制，Message

发送消息的时候最终调用sendEmptyMessageAtTime，通过Message.obtain();创建message并发送。享元模式就是从obtain这里切入。

public final boolean sendEmptyMessageAtTime(int what, long uptimeMillis) {
        Message msg = Message.obtain();
        msg.what = what;
        return sendMessageAtTime(msg, uptimeMillis);
    }

Message.obtain

message要么是从最后new Message返回一个新的对象，要么返回sPool。当返回sPool时就是返回已创建的重复对象

    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是一个单链表对象