享元模式是一种减少相似对象创建和销毁的设计模式，通过将对象状态分为不变和可变部分，实现内存节省和性能提升。例如，在线游戏中大量玩家角色可共享相同的不变属性，而每人特有的可变属性则单独存储，享元模式使用享元类存储不变属性，非享元类存储可变属性，并通过享元工厂管理对象的复用和共享。

定义

享元模式是一种对象设计模式，它用于减少大量相似对象（也称为“细粒度对象”）的创建和销毁，从而节省内存和提高性能。

享元模式的基本思想是将对象的内部状态分为两部分：不变部分和可变部分。不变部分包括所有对象共享的相同状态，而可变部分是每个对象特有的状态。通过将不变部分提取出来并存储在享元对象中，可以避免重复创建相同的对象，从而减少内存占用。

举一个简单的例子来说明享元模式的应用场景：假设当前正在开发一个在线游戏，游戏中有大量的玩家角色，每个角色都有相同的名称、等级和经验值等不变属性，但装备、技能等级等是每个角色特有的可变属性，在这种情况下，可以将玩家的不变属性存储在一个享元对象中，然后为每个角色分配一个可变属性的实例，这样，多个角色可以共享同一个享元对象，从而减少内存占用。

享元模式在实现时通常使用两个类：一个享元类（Flyweight）用于存储不变属性，另一个非享元类（Unshared）用于存储可变属性，通过享元工厂（FlyweightFactory）来管理享元对象的创建和销毁，以确保它们能够被正确地复用和共享。

代码案例

以下是一个未使用享元模式的反例代码，这个例子中创建了大量的相似对象，导致消耗大量的内存和性能，如下代码：

// 未使用享元模式的反例代码  
public class Circle {  
    private double x;  
    private double y;  
    private double radius;  
      
    // 构造函数，每次调用都会创建一个新的Circle对象  
    public Circle(double x, double y, double radius) {  
        this.x = x;  
        this.y = y;  
        this.radius = radius;  
    }  
      
    // 绘制圆形的方法  
    public void draw() {  
        System.out.println("Circle: Draw() [x : " + x + ", y :" + y + ", radius :" + radius);  
    }  
}  
  
// 客户端调用案例  
public class Client {  
    public static void main(String[] args) {  
        // 创建大量的Circle对象，这将消耗大量的内存和性能  
        for (int i = 0; i < 10; i++) {  
            Circle circle = new Circle(0, 0, 1); // 所有的圆都有相同的位置和半径  
            circle.draw();  
        }  
    }  
}

上面例子中，尽管所有的Circle对象都有相同的位置和半径，但仍然为每个对象分配了内存，如果需要创建数百万个这样的对象，那么内存消耗将是巨大的，此外，由于每个对象都需要被垃圾收集器处理，这也可能降低程序的性能。

如果使用享元模式，可以共享相同的Circle对象，从而大大减少内存消耗和提高性能，在享元模式中，通常会创建一个享元工厂来管理和重用对象，这样，即使需要大量的相似对象，也只需要存储它们的一个实例。

以下是一个使用享元模式的正例代码，在这个例子中，将使用享元模式来减少具有相同属性的Circle对象的创建，将会创建一个CircleFactory来管理Circle对象的创建和重用，如下代码：

// 享元模式中的抽象享元角色  
interface Shape {  
    void draw();  
}  
  
// 享元模式中的具体享元角色  
class Circle implements Shape {  
    private final String color;  
    private final int x;  
    private final int y;  
    private final int radius;  
  
    // 构造函数私有化，因为外部的类不应该直接实例化这个类，而应该通过工厂来获取实例  
    private Circle(String color, int x, int y, int radius) {  
        this.color = color;  
        this.x = x;  
        this.y = y;  
        this.radius = radius;  
    }  
  
    @Override  
    public void draw() {  
        System.out.println("Circle: Draw() [Color : " + color + ", x : " + x + ", y :" + y + ", radius :" + radius + "]");  
    }  
  
    // 根据属性创建Circle的静态内部类，作为享元工厂的实现  
    private static class CircleFactory {  
        // 使用HashMap存储已经创建的Circle对象，实现重用  
        private static final Map<String, Circle> circleMap = new HashMap<>();  
  
        // 获取Circle对象的方法，如果Map中没有则创建一个新的Circle对象并存入Map中  
        public static synchronized Circle getCircle(String color, int x, int y, int radius) {  
            String key = color + x + y + radius; // 将属性和在一起作为key，确保相同的属性可以得到相同的对象  
            if (!circleMap.containsKey(key)) {  
                circleMap.put(key, new Circle(color, x, y, radius));  
            }  
            return circleMap.get(key); // 返回对应key的Circle对象，如果已经存在则直接重用  
        }  
    }  
  
    // 提供一个静态方法来获取Circle对象，客户端应该通过这个方法来获取Circle对象而不是直接new  
    public static Circle getCircle(String color, int x, int y, int radius) {  
        return CircleFactory.getCircle(color, x, y, radius);  
    }  
}  
  
// 客户端调用案例  
public class Client {  
    public static void main(String[] args) {  
        // 通过享元工厂获取Circle对象，如果具有相同属性的对象已经存在，则直接重用该对象  
        for (int i = 0; i < 5; i++) {  
            Circle circle = Circle.getCircle("Red", 0, 0, 1); // 请求相同属性的圆形对象  
            circle.draw(); // 调用绘制方法，将看到是同一个对象被重用  
        }  
        System.out.println("------------------");  
        // 请求不同属性的圆形对象，将会创建新的对象实例  
        Circle anotherCircle = Circle.getCircle("Blue", 1, 1, 2);   
        anotherCircle.draw(); // 调用绘制方法，将看到是一个新的对象被创建并绘制  
    }  
}

在这个例子中，创建了一个Circle类来实现Shape接口，使用了一个私有的静态内部类CircleFactory来作为享元工厂，它使用一个HashMap来存储已经创建的Circle对象，客户端通过调用Circle.getCircle()方法来获取Circle对象，如果具有相同属性的对象已经存在于Map中，那么该方法将返回这个已经存在的对象，否则，它将创建一个新的对象并将其添加到Map中，这样，就可以重用具有相同属性的对象，从而减少内存消耗并提高性能。

核心总结

享元模式是一种用于优化性能的设计模式，它通过共享相同或相似对象来减少系统中对象的数量，从而节省内存和提高效率，其优点在于能够显著减少对象创建和销毁带来的开销，特别适用于需要大量相似对象但状态可外部化的场景。然而，享元模式也有缺点，它增加了系统的复杂性，需要额外的逻辑来管理共享对象池，并可能导致状态同步问题。当存在明确需要优化对象数量和内存占用时再考虑使用，同时要仔细设计和管理共享对象池，确保状态的一致性和正确性。

其它应用场景补充

数据库连接池，数据库连接池是享元模式最经典的使用场景之一，在这个场景中，创建数据库连接对象需要消耗大量的资源，而且这些对象的内部状态大部分都是相同的，因此，可以通过享元模式来共享这些对象，减少对象的创建和销毁，提高系统的性能和可扩展性。

线程池，线程池也是享元模式的一个应用场景，线程的创建和销毁需要消耗大量的资源，而且线程的内部状态大部分都是相同的，因此，可以通过享元模式来共享线程对象，避免频繁地创建和销毁线程。

大数据处理，在处理大量数据时，可能会存在大量的重复对象，如图像处理中的像素点、文本处理中的单词等，这些对象可以通过享元模式来减少内存消耗和提高处理速度。

其它场景？

完！