享元模式（Flyweight Pattern）主要用于减少创建对象的数量，以减少内存占用和提高性能。这种类型的设计模式属于结构型模式，它提供了减少对象数量从而改善应用所需的对象结构的方式。享元模式尝试重用现有的同类对象，如果未找到匹配的对象，则创建新对象。该模式主要用于解决：在有大量对象时，有可能会造成内存溢出，我们把其中共同的部分抽象出来，如果有相同的业务请求，直接返回在内存中已有的对象，避免重新创建。
    image.png
    image.png

    比如，池化技术就是一种享元模式的应用，比如下面的自定义线程池：

    1. @Slf4j(topic = "c.Pool")
    2. public class Pool {
    3.     // 1. 连接池大小
    4.     private final int poolSize;
    5.     // 2. 连接对象数组
    6.     private final Connection[] connections;
    7.     // 3. 连接状态数组 0 表示空闲， 1 表示繁忙
    8.     private final AtomicIntegerArray states;
    10.     // 4. 构造方法初始化
    11.     public Pool(int poolSize) {
    12.         this.poolSize = poolSize;
    13.         this.connections = new Connection[poolSize];
    14.         this.states = new AtomicIntegerArray(new int[poolSize]);
    15.         for (int i = 0; i < poolSize; i++) {
    16.             connections[i] = new MockConnection("连接" + (i + 1));
    17.         }
    18.     }
    20.     // 5. 借连接
    21.     public Connection borrow() {
    23.         while (true) {
    24.             for (int i = 0; i < poolSize; i++) {
    25.                 // 获取空闲连接
    26.                 if (states.get(i) == 0) {
    27.                     //CAS操作，线程安全
    28.                     if (states.compareAndSet(i, 0, 1)) {
    29.                         log.debug("borrow {}", connections[i]);
    30.                         return connections[i];
    31.                     }
    32.                 }
    33.             }
    34.             // 如果没有空闲连接，当前线程进入等待
    35.             synchronized (this) {
    36.                 try {
    37.                     log.debug("wait...");
    38.                     this.wait();
    39.                 } catch (InterruptedException e) {
    40.                     e.printStackTrace();
    41.                 }
    42.             }
    43.         }
    44.     }
    46.     // 6. 归还连接
    47.     public void free(Connection conn) {
    48.         for (int i = 0; i < poolSize; i++) {
    49.             if (connections[i] == conn) {
    50.                 states.set(i, 0);
    51.                 synchronized (this) {
    52.                     log.debug("free {}", conn);
    53.                     this.notifyAll();
    54.                 }
    55.                 break;
    56.             }
    57.         }
    58.     }
    60.     public static void main(String[] args) {
    61.         Pool pool = new Pool(2);
    62.         for (int i = 0; i < 5; i++) {
    63.             new Thread(() -> {
    64.                 Connection conn = pool.borrow();
    65.                 try {
    66.                     Thread.sleep(new Random().nextInt(1000));
    67.                 } catch (InterruptedException e) {
    68.                     e.printStackTrace();
    69.                 }
    70.                 pool.free(conn);
    71.             }).start();
    72.         }
    73.     }
    74. }
    76. class MockConnection implements Connection {
    77.  // 实现略
    78. }

    运行结果：
    image.png