[[404702]]

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

下面是本文目錄：

背景

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

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

享元模式提供了減少對象數(shù)量從而改善應(yīng)用所需的對象結(jié)構(gòu)的方式。

英文解釋：

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

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

屬于結(jié)構(gòu)性設(shè)計模式，其中結(jié)構(gòu)性設(shè)計模式有：代理、門面、裝飾器、享元、橋接、適配器、組合。

注意：

享元模式把一個對象的狀態(tài)分成內(nèi)部狀態(tài)和外部狀態(tài)，內(nèi)部狀態(tài)是不變的，外部狀態(tài)是變化的;然后通過共享不變的部分，達(dá)到減少對象數(shù)量并節(jié)約內(nèi)存的目的。

生活案例

房屋中介

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

個人身份證信息

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

高考志愿填報

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

圖書館

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

....

簡單代碼實現(xiàn)

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

public interface Book { 
    void borrow(); 
} 
/** 
 * @author java后端技術(shù)全棧 
 */ 
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后端技術(shù)全棧 
 */ 
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虛擬機(jī)"); 
        studenBorrow("java編程思想"); 
 
 
        //還了后，再借一次 
        studenBorrow("java 從入門到精通"); 
        studenBorrow("java 從入門到放棄"); 
        studenBorrow("JVM java虛擬機(jī)"); 
        studenBorrow("java編程思想"); 
 
        //還了后，再借一次 
        studenBorrow("java 從入門到精通"); 
        studenBorrow("java 從入門到放棄"); 
        studenBorrow("JVM java虛擬機(jī)"); 
        studenBorrow("java編程思想"); 
 
        //把每一本書借出去 
        for (Book book:bookList){ 
            book.borrow(); 
        } 
 
        System.out.println("學(xué)生一共借了 "+bookList.size()+"本書"); 
        System.out.println("學(xué)生一共借了 "+ bookFactory.bookSize()+"本書"); 
 
    } 
 
    private static void studenBorrow(String name) { 
        bookList.add(bookFactory.libToBorrow(name)); 
    } 
} 

運行結(jié)果

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

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

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

享元模式的UML類圖如下：

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

• 抽象享元角色(Book)：享元對象抽象基類或者接口，同時定義出對象的外部狀態(tài)和內(nèi)部狀態(tài)的接口或?qū)崿F(xiàn)。
• 具體享元角色(ConcreteBook)：實現(xiàn)抽象角色定義的業(yè)務(wù)。該角色的內(nèi)部狀態(tài)處理應(yīng)該與環(huán)境無關(guān)，不會出現(xiàn)一個操作改變內(nèi)部狀態(tài)、同時修改了外部狀態(tài)的情況。
• 享元工廠(BookFactory)：負(fù)責(zé)管理享元對象池和創(chuàng)建享元對象。

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

大佬們是怎樣使用的

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

Integer中的享元模式

下面這段代碼輸出什么?

/** 
 * 歡迎關(guān)注公眾號：java后端技術(shù)全棧 
 * 
 * @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); 
 
    } 
} 

很多人可能會認(rèn)為輸出

true 
true 

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

true 
false 

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

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

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

下面進(jìn)行一個簡要的分析：

關(guān)于Integer的緩存，推薦看這篇文章：

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

關(guān)于Integer 推薦：面試官：說說Integer緩存范圍

String中的享元模式

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

下面這段代碼輸出什么?

/** 
 * 歡迎關(guān)注公眾號：java后端技術(shù)全棧 
 * 
 * @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修飾的，以字面量的形式創(chuàng)建String變量時，JVM會在編譯期間就把該字面量“abcd”放到字符串常量池匯總，有Java程序啟動的時候就已經(jīng)加載到內(nèi)存中了。這個字符串常量的特點就是有且僅有一份相同的字面量，如果其他相同字面量，JVM則返回這個字面量的引用，如果沒有相同的字面量，則再字符串常量池中創(chuàng)建這個字面量并返回它的引用。

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

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

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

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

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

s9是s7和s8拼接而成，但是jvm并沒有對其進(jìn)行優(yōu)化，所以s1!=s9

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

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

JVM中的常量池也是享元模式的經(jīng)典實現(xiàn)之一。

關(guān)于String延伸內(nèi)容：

美團(tuán)面試題：String s = new String("111")會創(chuàng)建幾個對象?

Long中的享元模式

Long中和Integer中類似，也是最-128到127的數(shù)進(jìn)行了緩存，請看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); 
} 

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

在Apache Commons Pool中的享元模式

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

Apache Pool實現(xiàn)了對象池的功能，定義了對象的生成、銷毀、激活、鈍化等操作及其狀態(tài)轉(zhuǎn)換，并提供幾個默認(rèn)的對象池實現(xiàn)，

有如下幾個重要的角色：

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

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

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

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

享元模式的擴(kuò)展

享元模式中的狀態(tài)

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

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

內(nèi)部狀態(tài)指對象共享出來的信息，存儲在享元對象內(nèi)部，并且不會隨環(huán)境的改變而改變;

外部狀態(tài)指對象得以依賴的一個標(biāo)記，隨環(huán)境的改變而改變，不可共享。

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

優(yōu)缺點

優(yōu)點

• 減少對象的創(chuàng)建，降低內(nèi)存中對象的數(shù)量，降低系統(tǒng)的內(nèi)存，提高效率。
• 減少內(nèi)存之外的其他資源占用。

缺點

• 關(guān)注內(nèi)、外部狀態(tài)，關(guān)注線程安全問題。
• 使系統(tǒng)、程序的邏輯復(fù)雜化。

總結(jié)

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

一句話總結(jié)：

優(yōu)化資源配置，減少資源浪費

參考：Tom的設(shè)計模式課程

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

本文轉(zhuǎn)載自微信公眾號「Java后端技術(shù)全?！?，可以通過以下二維碼關(guān)注。轉(zhuǎn)載本文請聯(lián)系Java后端技術(shù)全棧公眾號。