#享元模式

public class StringPoolDemo {
    public static void main(String[] args) {
        // 字面量方式创建字符串，优先从常量池获取
        String s1 = "hello";
        String s2 = "hello";

        // new 方式强制在堆中创建新对象
        String s3 = new String("hello");

        System.out.println(s1 == s2);  // true，指向同一个对象
        System.out.println(s1 == s3);  // false，堆中不同对象
        System.out.println(s1 == s3.intern());  // true，intern() 从常量池获取
    }
}

public class IntegerDemo {
    public static void main(String[] args) {
        Integer a = 127;
        Integer b = 127;
        System.out.println(a == b);  // true

        Integer c = 128;
        Integer d = 128;
        System.out.println(c == d);  // false

        // 自动装箱的陷阱
        Integer e = 127;
        Integer f = Integer.valueOf(127);
        System.out.println(e == f);  // true
    }
}

public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high) {
        return IntegerCache.cache[i + (-IntegerCache.low)];
    }
    return new Integer(i);
}

// IntegerCache 预加载了 -128 到 127 的整数
private static class IntegerCache {
    static final int low = -128;
    static final int high;
    static final Integer cache[];

    static {
        int h = 127;
        // 允许通过 -Djava.lang.Integer.IntegerCache.high 设置上限
        high = java.lang.Integer.IntegerCache.high;
        int size = high - low + 1;
        cache = new Integer[size];
        for (int i = 0; i < size; i++) {
            cache[i] = new Integer(i + low);
        }
    }
}

// 享元接口
public interface Glyph {
    void draw(Context context);  // context 是外部状态
}

// 具体享元：字符
public class Character implements Glyph {
    private final char character;  // 内部状态

    public Character(char character) {
        this.character = character;
    }

    @Override
    public void draw(Context context) {
        System.out.println("绘制字符 '" + character + "' at ("
                          + context.getX() + ", " + context.getY()
                          + ") with color " + context.getColor());
    }
}

// 具体享元：空格（经常出现，可以特殊优化）
public class Space implements Glyph {
    public static final Space INSTANCE = new Space();

    private Space() {}

    @Override
    public void draw(Context context) {
        // 空格不需要绘制，但需要推进光标
    }
}

// 外部状态
public class Context {
    private int x, y;
    private String color;

    public Context(int x, int y, String color) {
        this.x = x;
        this.y = y;
        this.color = color;
    }

    public int getX() { return x; }
    public int getY() { return y; }
    public String getColor() { return color; }
}

// 享元工厂
public class GlyphFactory {
    private final Map<Character, Character> characters = new HashMap<>();

    public Glyph getCharacter(char ch) {
        Character key = new Character(ch);
        return characters.computeIfAbsent(key, k -> k);
    }

    public Glyph getSpace() {
        return Space.INSTANCE;  // 单例
    }
}

public class FlyweightDemo {
    public static void main(String[] args) {
        GlyphFactory factory = new GlyphFactory();

        // 创建 1000 个 'A'
        for (int i = 0; i < 1000; i++) {
            Glyph glyph = factory.getCharacter('A');
            glyph.draw(new Context(i * 10, 0, "black"));
        }

        // 只创建了 1 个 Character('A') 实例
        System.out.println("实际创建的对象数: " +
            ((HashMap<?, ?>) getCharactersField(factory)).size());
    }
}

public class ThreadPoolDemo {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(4);

        // 提交 100 个任务，但只有 4 个线程
        for (int i = 0; i < 100; i++) {
            final int taskId = i;
            executor.submit(() -> {
                System.out.println("任务 " + taskId + " 由线程 "
                    + Thread.currentThread().getName() + " 执行");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

        executor.shutdown();
    }
}