什么是享元模式？

运用共享技术有效地支持大量细粒度的对象。重用现有的同类对象，如果未找到匹配的对象，则创建新对象。主要用于减少创建对象的数量，以减少内存占用和提高性能。

适用场景

大量对象耗费大量内存，复用相似对象节省内存

代码实现

示例：围棋，围棋的棋子可以简化为两个对象，黑棋和白棋，不同的是棋子的坐标。

  1. /**
  2.  * 棋子
  3.  */
  4. class Piece {
  5.     protected Color color;//颜色
  6.     protected int x;//x坐标
  7.     protected int y;//y坐标
  9.     public Piece(Color color, int x, int y) {
  10.         this.color = color;
  11.         this.x = x;
  12.         this.y = y;
  13.     }
  15.     @Override
  16.     public String toString() {
  17.         return "棋子：" + color + ",横坐标：" + x + ",纵坐标：" + y;
  18.     }
  20. }
  22. /**
  23.  * 枚举 棋子类型
  24.  */
  25. enum Color {
  26.     Black,
  27.     White;
  28. }
  30. /**
  31.  * 棋子工厂类，实现对象共享
  32.  */
  33. class PieceFactory {
  34.     private static final Map<Color, Piece> map = new ConcurrentHashMap<>();
  36.     public synchronized static Piece getPiece(@NotNull Color color, int x, int y) {
  37.         Piece piece = map.get(color);
  38.         if (null == piece) {
  39.             piece = new Piece(color, x, y);
  40.             map.put(color, piece);
  41.         }
  42.         System.out.println("内存占用：" + map.size());
  43.         return piece;
  44.     }
  45. }
  48. /**
  49.  * 组合模式测试
  50.  */
  51. public class FlyweightPattern {
  52.     public static void main(String[] args) {
  53.         //模拟棋盘 100*100
  54.         final int width = 100;
  55.         final int high = 100;
  56.         //随机获取一百个棋子
  57.         final int count = 100;
  59.         //两个线程 模拟两个人对弈
  61.         //对弈者1
  62.         new Thread(() -> {
  63.             Random random = new Random();
  64.             for (int i = 0; i < count; i++) {
  65.                 int x = random.nextInt(width);
  66.                 int y = random.nextInt(high);
  67.                 Piece piece = null;
  68.                 //利用奇数偶数模拟黑白棋子
  69.                 if (i % 2 != 0) {//奇数 白棋
  70.                     piece = PieceFactory.getPiece(Color.White, x, y);
  71.                 } else {
  72.                     piece = PieceFactory.getPiece(Color.Black, x, y);
  73.                 }
  74.                 System.out.println(piece);
  75.             }
  76.         }).start();
  78.         //对弈者2
  79.         new Thread(() -> {
  80.             Random random = new Random();
  81.             for (int i = 0; i < count; i++) {
  82.                 int x = random.nextInt(width);
  83.                 int y = random.nextInt(high);
  84.                 Piece piece = null;
  85.                 //利用奇数偶数模拟黑白棋子
  86.                 if (i % 2 != 0) {//奇数 白棋
  87.                     piece = PieceFactory.getPiece(Color.White, x, y);
  88.                 } else {
  89.                     piece = PieceFactory.getPiece(Color.Black, x, y);
  90.                 }
  91.                 System.out.println(piece);
  92.             }
  93.         }).start();
  96.         //输出：
  97.         //内存占用：1
  98.         //内存占用：1
  99.         //棋子：Black,横坐标：43,纵坐标：52
  100.         //棋子：Black,横坐标：43,纵坐标：52
  101.         //内存占用：2
  102.         //棋子：White,横坐标：88,纵坐标：68
  103.         //内存占用：2
  104.         //棋子：White,横坐标：88,纵坐标：68
  105.         //内存占用：2
  106.         //棋子：Black,横坐标：43,纵坐标：52
  107.         //内存占用：2
  108.         //棋子：Black,横坐标：43,纵坐标：52
  109.         //内存占用：2
  110.         //棋子：White,横坐标：88,纵坐标：68
  111.         //内存占用：2
  112.         //棋子：White,横坐标：88,纵坐标：68
  113.         //内存占用：2
  114.         //棋子：Black,横坐标：43,纵坐标：52
  115.         //内存占用：2
  116.         //棋子：Black,横坐标：43,纵坐标：52
  117.         //内存占用：2
  118.         //棋子：White,横坐标：88,纵坐标：68
  119.         //内存占用：2
  120.         //棋子：White,横坐标：88,纵坐标：68
  121.         //内存占用：2
  122.         //棋子：Black,横坐标：43,纵坐标：52
  123.         //内存占用：2
  124.         //棋子：Black,横坐标：43,纵坐标：52
  125.         //.....
  127.     }
  129. }