Flyweightaka Interning, Cache of shared objects

Trong rạp chiếu phim, 300 khán giả xem cùng MỘT bộ phim trên MỘT màn hình — rạp không phát cho mỗi người một máy chiếu riêng. Thứ riêng của từng người chỉ là số ghế và ly bắp. Phim là phần dùng chung (intrinsic), số ghế là phần riêng (extrinsic).In a cinema, 300 viewers watch ONE film on ONE screen — the cinema doesn't hand each person a projector. What's personal is just the seat number and the popcorn. The film is the shared part (intrinsic); the seat is the personal part (extrinsic).

Thành phần tham giaParticipants

Flyweight

Object chứa trạng thái intrinsic, BẤT BIẾN, dùng chung (MarkerStyle).Holds intrinsic, IMMUTABLE, shared state (MarkerStyle).

FlyweightFactory

Cache và phát flyweight theo key; tạo mới chỉ khi chưa có.Caches and hands out flyweights by key; creates one only if missing.

Context

Giữ trạng thái extrinsic + tham chiếu tới flyweight (DriverMarker).Holds extrinsic state + a reference to a flyweight (DriverMarker).

Client

Lấy flyweight từ factory, không tự new.Gets flyweights from the factory, never news them up itself.

Dùng Tự chạy hoặc phím mũi tên để đi qua từng bước gọi giữa các object. Console hiển thị output tương ứng của chương trình.Use Autoplay or the arrow keys to step through each call between objects. The console shows the matching program output.

Cùng một bài toán, hai ngôn ngữ. Rê chuột hoặc focus vào chú thích (số màu cam) để làm nổi bật dòng code tương ứng.Same problem, two languages. Hover or focus an annotation (orange number) to highlight its line.

package com.ride.map;

import org.springframework.stereotype.Component;
import java.io.IOException;
import java.io.UncheckedIOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

// Flyweight: intrinsic, heavy, shared. Never mutate it.
record MarkerStyle(String vehicle, String color, byte[] icon) {}1

@Component
public class MarkerStyleFactory {
    private final Map<String, MarkerStyle> cache = new ConcurrentHashMap<>();2

    public MarkerStyle get(String vehicle) {
        // computeIfAbsent: each icon is loaded at most once, thread-safe
        return cache.computeIfAbsent(vehicle, this::load);3
    }

    public int size() { return cache.size(); }

    private MarkerStyle load(String vehicle) {
        try {
            byte[] icon = Files.readAllBytes(Path.of("icons", vehicle + ".png"));4
            String color = vehicle.equals("car") ? "#00B14F" : "#FF6F00";
            return new MarkerStyle(vehicle, color, icon);
        } catch (IOException e) {
            throw new UncheckedIOException(e);
        }
    }
}

package fleet

import (
	"fmt"
	"os"
	"sync"
)

// MarkerStyle is the flyweight: heavy, immutable, shared by thousands of markers.
type MarkerStyle struct {
	Vehicle string
	Color   string
	Icon    []byte // ~40 KB PNG, loaded once per vehicle type1
}

// StyleFactory hands out shared styles; one entry per vehicle type.
type StyleFactory struct {
	mu     sync.Mutex
	styles map[string]*MarkerStyle2
}

func NewStyleFactory() *StyleFactory {
	return &StyleFactory{styles: make(map[string]*MarkerStyle)}
}

func (f *StyleFactory) Get(vehicle string) (*MarkerStyle, error) {
	f.mu.Lock()3
	defer f.mu.Unlock()
	if s, ok := f.styles[vehicle]; ok {4
		return s, nil // shared instance
	}
	icon, err := os.ReadFile("icons/" + vehicle + ".png")
	if err != nil {
		return nil, fmt.Errorf("load icon %s: %w", vehicle, err)
	}
	s := &MarkerStyle{Vehicle: vehicle, Color: colorFor(vehicle), Icon: icon}
	f.styles[vehicle] = s
	return s, nil
}

func colorFor(vehicle string) string {
	if vehicle == "car" {
		return "#00B14F"
	}
	return "#FF6F00"
}

• Integer cache và String poolInteger cache and the String pool

  Integer.valueOf(100) == Integer.valueOf(100) là true vì -128..127 được cache sẵn; chuỗi literal được intern dùng chung. (Vì thế đừng so sánh Integer bằng ==.)Integer.valueOf(100) == Integer.valueOf(100) is true because -128..127 is pre-cached; string literals are interned and shared. (Which is why you never compare Integers with ==.)

• Package unique (Go 1.23+) và header HTTPGo's unique package (1.23+) and HTTP headers

  unique.Make(s) trả về Handle dùng chung cho các giá trị bằng nhau; net/textproto dùng sẵn các chuỗi header phổ biến để tránh cấp phát lặp lại.unique.Make(s) returns a shared Handle for equal values; net/textproto reuses common header strings to avoid repeated allocations.

• Bản đồ, game, trình soạn thảoMaps, games, text editors

  Marker xe trên bản đồ, cây/đạn trong game, glyph font trong editor — hàng triệu object dùng chung vài hình dạng.Vehicle markers on maps, trees/bullets in games, font glyphs in editors — millions of objects sharing a few shapes.

• Danh mục dùng chung trong bộ nhớShared in-memory reference data

  Hàng triệu đơn hàng tham chiếu tới vài chục object Province/Currency/ShippingMethod bất biến thay vì mỗi đơn một bản copy.Millions of orders reference a few dozen immutable Province/Currency/ShippingMethod objects instead of each holding its own copy.