[[404702]]

大家好，我是老田，今天我給大家分享設計模式中的享元模式。用貼切的生活故事，以及真實項目場景來講設計模式，最后用一句話來總結這個設計模式。

下面是本文目錄：

背景

享元模式(Flyweight Pattern)又叫作輕量級模式，是對象池的一種實現。

類似線程池，線程池可以避免不停地創建和銷毀多個對象，消耗性能。

享元模式提供了減少對象數量從而改善應用所需的對象結構的方式。

英文解釋：

Use sharing to support large numbers of fine-grained objects efficiently.

享元模式(Flyweight Pattern)其宗旨是共享細粒度對象，將多個對同一對象的訪問集中起來，不必為每個訪問者都創建一個單獨的對象， 主要用于減少創建對象的數量，以減少內存占用和提高性能。

屬于結構性設計模式，其中結構性設計模式有：代理、門面、裝飾器、享元、橋接、適配器、組合。

注意：

享元模式把一個對象的狀態分成內部狀態和外部狀態，內部狀態是不變的，外部狀態是變化的;然后通過共享不變的部分，達到減少對象數量并節約內存的目的。

生活案例

房屋中介

只要是個城市，就少不了房屋中介，房屋中介存有大量的出租房屋信息，并且一家房屋中介往往會有多個門店，但是所有門店都共享這些房屋信息(共享的是出租房屋的信息)。

個人身份證信息

每個中國公民都有一張身份證，并且這張身份證信息在公安系統中是共享的，全國各公安局派出所都會共享你的身份證信息(共享的是個人身份信息)。

高考志愿填報

每所大學在每個省都有明確的招收名額，這些名額對于該省的所有高考生而言都是共享的(共享的是招收名額)。

圖書館

圖書館里的可借書籍，對多有讀者是共享的，大家都可以查詢此書是否已經被借出去，還剩基本可借(共享的是圖書)。

....

簡單代碼實現

下面我們通過一個案例來演示享元模式(圖書館為例)。

public interface Book { 
    void borrow(); 
} 
/** 
 * @author java后端技術全棧 
 */ 
public class ConcreteBook implements Book { 
    //被借出去的書名 
    private String name; 
 
    public ConcreteBook(String name) { 
        this.name = name; 
    } 
 
    @Override 
    public void borrow() { 
        System.out.println("圖書館借出去一本書，書名："+this.name); 
    } 
} 
import java.util.HashMap; 
import java.util.Map; 
 
/** 圖書館 
 * @author java后端技術全棧 
 */ 
public class Llibrary { 
    private Map<String, Book> bookMap = new HashMap<>(); 
 
    private Llibrary() { 
    } 
 
    //只能有一個圖書館 
    public static Llibrary getInstance() { 
        return LazyHolder.LAZY_STATIC_SINGLETON; 
    } 
 
    //通過書名name來借書 
    public Book libToBorrow(String name) { 
        Book book; 
        //如果圖書館有，直接把書借走 
        if (bookMap.containsKey(name)) { 
            book = bookMap.get(name); 
        } else {//圖書館沒有，則錄入一本書，然后把書借走 
            book = new ConcreteBook(name); 
            bookMap.put(name, book); 
        } 
        return book; 
    } 
 
    //返回還有多少本書 
    public int bookSize() { 
        return bookMap.size(); 
    } 
    private static class LazyHolder { 
        private static final Llibrary LAZY_STATIC_SINGLETON = new Llibrary(); 
    } 
} 
import java.util.ArrayList; 
import java.util.List; 
 
public class Student { 
    private static List<Book> bookList = new ArrayList<>(); 
    private static BookFactory bookFactory; 
 
    public static void main(String[] args) { 
        bookFactory = BookFactory.getInstance(); 
 
        studenBorrow("java 從入門到精通"); 
        studenBorrow("java 從入門到放棄"); 
        studenBorrow("JVM java虛擬機"); 
        studenBorrow("java編程思想"); 
 
 
        //還了后，再借一次 
        studenBorrow("java 從入門到精通"); 
        studenBorrow("java 從入門到放棄"); 
        studenBorrow("JVM java虛擬機"); 
        studenBorrow("java編程思想"); 
 
        //還了后，再借一次 
        studenBorrow("java 從入門到精通"); 
        studenBorrow("java 從入門到放棄"); 
        studenBorrow("JVM java虛擬機"); 
        studenBorrow("java編程思想"); 
 
        //把每一本書借出去 
        for (Book book:bookList){ 
            book.borrow(); 
        } 
 
        System.out.println("學生一共借了 "+bookList.size()+"本書"); 
        System.out.println("學生一共借了 "+ bookFactory.bookSize()+"本書"); 
 
    } 
 
    private static void studenBorrow(String name) { 
        bookList.add(bookFactory.libToBorrow(name)); 
    } 
} 

運行結果

圖書館借出去一本書，書名：java 從入門到精通 
圖書館借出去一本書，書名：java 從入門到放棄 
圖書館借出去一本書，書名：JVM java虛擬機 
圖書館借出去一本書，書名：java編程思想 
圖書館借出去一本書，書名：java 從入門到精通 
圖書館借出去一本書，書名：java 從入門到放棄 
圖書館借出去一本書，書名：JVM java虛擬機 
圖書館借出去一本書，書名：java編程思想 
圖書館借出去一本書，書名：java 從入門到精通 
圖書館借出去一本書，書名：java 從入門到放棄 
圖書館借出去一本書，書名：JVM java虛擬機 
圖書館借出去一本書，書名：java編程思想 
學生一共借了 12本書 
學生一共借了 4本書 

其實，圖書館只有四本書，但是多個人借，A借來看完了，B再去借，B還了C再去借。

這些書籍就被大家共享了。

享元模式的UML類圖如下：

由上圖可以看到，享元模式主要包含3個角色。

• 抽象享元角色(Book)：享元對象抽象基類或者接口，同時定義出對象的外部狀態和內部狀態的接口或實現。
• 具體享元角色(ConcreteBook)：實現抽象角色定義的業務。該角色的內部狀態處理應該與環境無關，不會出現一個操作改變內部狀態、同時修改了外部狀態的情況。
• 享元工廠(BookFactory)：負責管理享元對象池和創建享元對象。

也許這個例子你還是不太明白，下面我們就用工作中常見的場景來解釋一通。

大佬們是怎樣使用的

關于享元模式，在JDK中大量的使用，比如：String、Integer、Long等類中，都有使用到。

Integer中的享元模式

下面這段代碼輸出什么?

/** 
 * 歡迎關注公眾號：java后端技術全棧 
 * 
 * @author 田維常 
 * @date 2021/06/02 19:30 
 */ 
public class IntegerDemo { 
    public static void main(String[] args) { 
        Integer a = 100; 
        Integer b = Integer.valueOf(100); 
        System.out.println(a == b); 
 
        Integer c = new Integer(1000); 
        Integer d = Integer.valueOf(1000); 
        System.out.println(c == d); 
 
    } 
} 

很多人可能會認為輸出

true 
true 

其實，非也，這里最終輸出的是：

true 
false 

為什么呢?100就可以比較，1000就不能比較了?

其實，在Integer里就用到了享元模式，它就是把-128到127這個范圍的數據緩存起來(放在Integer類型的數組中)。

static final int low = -128; 
public static Integer valueOf(int i) { 
    //high默認是127 
    if (i >= IntegerCache.low && i <= IntegerCache.high) 
        return IntegerCache.cache[i + (-IntegerCache.low)]; 
    return new Integer(i); 
} 

下面進行一個簡要的分析：

關于Integer的緩存，推薦看這篇文章：

這里Integer里的IntegerCache里就用到了享元模式。

關于Integer 推薦：面試官：說說Integer緩存范圍

String中的享元模式

Java中講String類定義為final不能繼承，并且將屬性value也定義為final便是不可變，JVM中字符串一般保存在字符串常量池中，Java會確保一個字符串在常量池中只會有一份拷貝，這個字符串常量池在JDK1.6中位于方法區(永久代)中，而JDK1.7以后，JVM講其從方法區移動到了堆heap中。

下面這段代碼輸出什么?

/** 
 * 歡迎關注公眾號：java后端技術全棧 
 * 
 * @author 田維常 
 * @date 2021/06/03 
 */ 
public class StringDemo { 
    public static void main(String[] args) throws Exception { 
        String s1 = "abcd"; 
        String s2 = "abcd"; 
 
 
        String s3 = "ab" + "cd"; 
        String s4 = "ab" + new String("cd"); 
 
        String s5 = new String("abcd"); 
        String s6 = s5.intern(); 
 
        String s7 = "a"; 
        String s8 = "bcd"; 
 
        String s9 = s7 + s8; 
 
        System.out.println("s1 == s2 " + (s1 == s2)); 
 
        System.out.println("s1 == s3 " + (s1 == s3)); 
        System.out.println("s1 == s4 " + (s1 == s4)); 
        System.out.println("s1 == s6 " + (s1 == s6)); 
        System.out.println("s1 == s9 " + (s1 == s9)); 
        System.out.println("s4 == s5 " + (s4 == s5)); 
 
    } 
} 

String類中的value是final修飾的，以字面量的形式創建String變量時，JVM會在編譯期間就把該字面量“abcd”放到字符串常量池匯總，有Java程序啟動的時候就已經加載到內存中了。這個字符串常量的特點就是有且僅有一份相同的字面量，如果其他相同字面量，JVM則返回這個字面量的引用，如果沒有相同的字面量，則再字符串常量池中創建這個字面量并返回它的引用。

由于s2指向字面量"abcd"在常量池中已經存在了(s1先于s2)，于是JVM就返回這個字面量綁定的引用，所以s1==s2。

s3中字面量的拼接其實在JVM層已經做了優化，在JVM編譯期間就對s3的拼接做了優化，所以s1、s2、s3都可以理解為是同一個，即s1==s3。

s4中的new String("cd")，此時生成了兩個對象，"cd"和new String("cd")，"cd"存在于字符串常量池中，new String("cd")存在于堆heap中，String s4="ab"+ new String("cd");實質上是兩個對象的相加，編譯器不會對其進行優化，相加的結果存在于堆heap中，而s2存在于字符串常量池中，當然不相等，即s1!=s4。

s4和s5最終的結果都是在堆中，所以此時s4!=s5

s5.intern()方法能是一個維度對總的字符串在運行期間動態地加入到字符串常量池中(字符串常量池的內容是程序啟動的時候就以及酒精加載好了，如果字符串常量池中存在該對象對應的字面量，則返回該字面量在字符串常量池中的引用，否則，創建復制一份該字面量到字符串常量池中并發那會它的引用)，因此s1==s6。

s9是s7和s8拼接而成，但是jvm并沒有對其進行優化，所以s1!=s9

最后，上面這段代碼輸出：

s1 == s2 true 
s1 == s3 true 
s1 == s4 false 
s1 == s6 true 
s1 == s9 false 
s4 == s5 false 

JVM中的常量池也是享元模式的經典實現之一。

關于String延伸內容：

美團面試題：String s = new String("111")會創建幾個對象?

Long中的享元模式

Long中和Integer中類似，也是最-128到127的數進行了緩存，請看Long中的valueOf()方法源碼部分：

public static Long valueOf(long l) { 
    final int offset = 128; 
    if (l >= -128 && l <= 127) { // will cache 
        return LongCache.cache[(int)l + offset]; 
    } 
    return new Long(l); 
} 

這個就沒必要進行演示了，和Integer一樣，都是使用了緩存，也就是享元模式。

在Apache Commons Pool中的享元模式

對象池化的基本思路是：將用過的對象保存起來，等下一次需要這種對象的時候，再拿出來重復使用，從而在一定程度上減少頻繁創建對象造成的消耗。用于充當保存對象的“容器”的對象，被稱為對象池(Object Pool，簡稱Pool)。

Apache Pool實現了對象池的功能，定義了對象的生成、銷毀、激活、鈍化等操作及其狀態轉換，并提供幾個默認的對象池實現，

有如下幾個重要的角色：

• Pooled Object(池化對象)：用于封裝對象(例如，線程、數據庫連接和TCP連接)，將其包裹成可被對象池管理的對象。
• Pooled Object Factory(池化對象工廠)：定義了操作Pooled Object實例生命周期的一些方法，Pooled Object Factory必須實現線程安全。
• Object Pool(對象池)：Object Pool負責管理Pooled Object，例如，借出對象、返回對象、校驗對象、有多少激活對象和有多少空閑對象。

在ObjectPool類的子類org.apache.commons.pool2.impl.GenericObjectPool種有個屬性：

private final Map<IdentityWrapper<T>, PooledObject<T>> allObjects; 

這個Map就是用來緩存對象的，所以這里也是享元模式的實現。

享元模式的擴展

享元模式中的狀態

享元模式的定義提出了兩個要求：細粒度和共享對象。

因為要求細粒度，所以不可避免地會使對象數量多且性質相近，此時我們就將這些對象的信息分為兩個部分：內部狀態和外部狀態。

內部狀態指對象共享出來的信息，存儲在享元對象內部，并且不會隨環境的改變而改變;

外部狀態指對象得以依賴的一個標記，隨環境的改變而改變，不可共享。

比如：連接池中的連接對象，保存在連接對象中的用戶名、密碼、連接URL等信息，在創建對象的時候就設置好了，不會隨環境的改變而改變，這些為內部狀態。而當每個連接要被回收利用時，我們需要將它標記為可用狀態，這些為外部狀態。

優缺點

優點

• 減少對象的創建，降低內存中對象的數量，降低系統的內存，提高效率。
• 減少內存之外的其他資源占用。

缺點

• 關注內、外部狀態，關注線程安全問題。
• 使系統、程序的邏輯復雜化。

總結

享元模式，單從概念來講估計很多人不是很理解，但是從Integer、String已經生活中的場景結合起來理解，就能輕松理解享元模式，享元模式的實現基本上都伴隨著一個集合用來存這些對象。

一句話總結：

優化資源配置，減少資源浪費

參考：Tom的設計模式課程

好了，今天的分享就到此結束，希望大家能明白什么是享元模式，享元模式的思想我們在開發中是否能借鑒，面試的時候就不要再說你不會設計模式了。

本文轉載自微信公眾號「Java后端技術全棧」，可以通過以下二維碼關注。轉載本文請聯系Java后端技術全棧公眾號。