Flyweight Pattern: Efficient Object Sharing

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

// Naive character representation
class FormattedCharacter {
    char character;           // 2 bytes
    String fontFamily;        // 4-8 bytes (reference) + String object overhead
    int fontSize;             // 4 bytes
    Color textColor;          // 4-8 bytes (reference) + Color object overhead
    boolean isBold;           // 1 byte
    boolean isItalic;         // 1 byte  
    boolean isUnderlined;     // 1 byte
    int xPosition;            // 4 bytes
    int yPosition;            // 4 bytes
    
    // Object overhead: ~16 bytes (header + padding)
    // Total per character: ~50+ bytes minimum
    // With referenced objects: easily 100+ bytes
    
    // Document with 50,000 characters:
    // 50,000 × 100 bytes = 5 MB just for character objects
    
    // But most characters share formatting!
    // A paragraph of text in "Arial 12pt black" duplicates
    // font info for every single character
}
 
// The redundancy is staggering:
// "Hello, World!" - 13 characters
// If all are Arial 12pt black regular text:
// - Same fontFamily: "Arial" duplicated 13 times
// - Same fontSize: 12 duplicated 13 times
// - Same textColor: black duplicated 13 times
// - Same isBold, isItalic, isUnderlined: false × 3 × 13 times
// Only the character and position are unique!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

/**
 * Naive document rendering approach.
 * 
 * This implementation creates a full object for every character,
 * storing redundant formatting information millions of times.
 */
public class NaiveDocumentRenderer {
    
    private List<FormattedCharacter> characters = new ArrayList<>();
    
    public void loadDocument(Document document) {
        for (Page page : document.getPages()) {
            for (TextRun textRun : page.getTextRuns()) {
                // Each text run has consistent formatting
                String font = textRun.getFontFamily();
                int size = textRun.getFontSize();
                Color color = textRun.getColor();
                boolean bold = textRun.isBold();
                boolean italic = textRun.isItalic();
                
                String text = textRun.getText();
                int x = textRun.getX();
                int y = textRun.getY();
                
                for (int i = 0; i < text.length(); i++) {
                    // PROBLEM: Creating a new object for EVERY character
                    // Font, size, color, bold, italic are identical
                    // for all characters in this run!
                    FormattedCharacter fc = new FormattedCharacter(
                        text.charAt(i),     // Only this differs!
                        font,               // Duplicated
                        size,               // Duplicated
                        color,              // Duplicated
                        bold,               // Duplicated
                        italic,             // Duplicated
                        false,              // Duplicated
                        x + i * getCharWidth(text.charAt(i), font, size),
                        y
                    );
                    characters.add(fc);
                }
            }
        }
        
        // Result: millions of FormattedCharacter objects
        // Each storing redundant font/color/style information
        // Memory usage: catastrophic
        // GC pressure: severe
    }
    
    // Document with 300,000 characters:
    // - 300,000 FormattedCharacter objects created
    // - Each ~100 bytes = 30 MB for this ONE document
    // - Plus the String objects for fontFamily (many duplicates)
    // - Plus the Color objects (many duplicates)
    // - Total: easily 50+ MB per document
    
    private int getCharWidth(char c, String font, int size) {
        // Font metrics calculation
        return size / 2; // Simplified
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

/**
 * Demonstration of memory exhaustion from object explosion.
 * 
 * This simulation shows what happens when naive object creation
 * meets real-world data volumes.
 */
public class MemoryExhaustionDemo {
    
    public static void demonstrateProblem() {
        List<FormattedCharacter> document = new ArrayList<>();
        
        // Simulating document loading
        int charactersLoaded = 0;
        
        try {
            // A "modest" 500-page technical manual
            for (int page = 0; page < 500; page++) {
                for (int line = 0; line < 50; line++) {
                    for (int character = 0; character < 80; character++) {
                        // Every character creates a full object
                        document.add(new FormattedCharacter(
                            'A',                        // Character
                            "Times New Roman",          // Always the same!
                            12,                         // Always the same!
                            Color.BLACK,                // Always the same!
                            false, false, false,        // Always the same!
                            character * 10,             // Position X
                            page * 600 + line * 12      // Position Y
                        ));
                        charactersLoaded++;
                    }
                }
                
                // Progress indicator
                if (page % 50 == 0) {
                    Runtime runtime = Runtime.getRuntime();
                    long usedMB = (runtime.totalMemory() - runtime.freeMemory()) 
                                  / 1024 / 1024;
                    System.out.printf("Page %d: %,d chars, %d MB used%n",
                        page, charactersLoaded, usedMB);
                }
            }
        } catch (OutOfMemoryError e) {
            System.err.println("CRASHED at " + charactersLoaded + " characters!");
            System.err.println("The document was mostly 'Times New Roman 12pt Black'");
            System.err.println("But we stored that info 2 MILLION times!");
        }
        
        // Expected output (with limited heap):
        // Page 0: 4,000 chars, 2 MB used
        // Page 50: 204,000 chars, 25 MB used
        // Page 100: 404,000 chars, 48 MB used
        // Page 150: 604,000 chars, 71 MB used
        // ...
        // CRASHED at 1,847,293 characters!
        // The document was mostly 'Times New Roman 12pt Black'
        // But we stored that info 2 MILLION times!
    }
}