享元模式：最小化内存使用的共享对象模式

享元模式是一种设计模式，旨在通过共享对象以减少内存占用，特别是在存在大量相似对象时。这种模式将对象的状态分为内部状态和外部状态，从而使多个对象可以共享相同的内部状态，而外部状态则在需要时传递。

 

结构

享元模式由以下几个核心组件组成：

• Flyweight 接口：定义共享对象的接口，包含用于传递外部状态的方法。
• ConcreteFlyweight 类：实现 Flyweight 接口，存储内部状态。
• UnsharedConcreteFlyweight 类：非共享的享元对象，不会被共享。
• FlyweightFactory 类：管理和创建享元对象，确保共享对象得到正确的重用。

工作原理

在享元模式中，对象的状态被划分为内部状态和外部状态。内部状态是可以共享的，而外部状态则是变化的，并在需要时传递给对象。

共享相同内部状态的对象可以被多个客户端共享，从而减少内存使用。当需要创建一个新的对象时，工厂类会检查是否已存在具有相同内部状态的对象，如果存在则重用它，否则创建一个新的对象。

优点

• 减少内存占用：通过共享相同的内部状态，减少了大量相似对象的内存占用。
• 提高性能：重用现有对象可以避免频繁的对象创建和销毁操作，提高了系统性能。
• 简化对象管理：通过集中管理对象的创建和重用，简化了对象管理的复杂性。

缺点

• 增加系统复杂性：引入了额外的对象管理和共享逻辑，可能会增加系统的复杂性。
• 需要维护外部状态：外部状态的传递和管理可能需要一定的复杂性。

适用场景

享元模式适用于以下情况：

• 存在大量相似对象，且它们可以共享一部分相同的内部状态。
• 对象的内部状态较多，导致内存占用较大。
• 对象的创建和销毁开销较大。

实际应用

1. 文字编辑器中的字符对象共享：在文字编辑器中，字符对象可以被共享，以减少内存占用。
2. 电子游戏中的角色对象共享：在电子游戏中，相同类型的角色对象可以共享一些状态，如外观和属性。
3. 数据库连接池中的连接对象共享：在数据库连接池中，可以共享连接对象以提高数据库访问的性能。

示例代码

// Flyweight 接口
interface Shape {
    void draw();
}

// ConcreteFlyweight 类
class Circle implements Shape {
    private String color;

    public Circle(String color) {
        this.color = color;
    }

    @Override
    public void draw() {
        System.out.println("Drawing a " + color + " circle.");
    }
}

// FlyweightFactory 类
class ShapeFactory {
    private static final Map<String, Shape> circleMap = new HashMap<>();

    public static Shape getCircle(String color) {
        Shape circle = circleMap.get(color);

        if (circle == null) {
            circle = new Circle(color);
            circleMap.put(color, circle);
        }

        return circle;
    }
}

// 客户端代码
public class Main {
    private static final String[] colors = {"Red", "Green", "Blue"};

    public static void main(String[] args) {
        for (int i = 0; i < 20; i++) {
            Circle circle = (Circle) ShapeFactory.getCircle(getRandomColor());
            circle.draw();
        }
    }

    private static String getRandomColor() {
        return colors[(int) (Math.random() * colors.length)];
    }
}

总结

享元模式是一种有效地减少内存占用的设计模式，特别适用于存在大量相似对象的场景。通过共享相同的内部状态，可以减少对象的创建和销毁开销，提高系统性能。然而，需要注意管理外部状态的复杂性和系统复杂性的增加。