Flyweight Pattern

Flyweight Pattern

Flyweight Pattern 은 메모리 상의 동일한 객체가 반복적으로 사용될 경우, 그 내부의 불변 데이터를 공유하여 메모리 낭비를 줄이는 구조적 설계 패턴이다. 객체의 상태를 고유 상태와 외부 상태로 분리하여, 공유 가능한 고유 상태만을 플라이웨이트 객체에 저장하고 팩토리를 통해 인스턴스를 관리한다.

특히 대규모 객체를 반복적으로 생성·사용하는 GUI 요소, 게임 오브젝트, 텍스트 렌더링 등의 환경에서 효과적이다. 이 패턴은 객체 간 차이를 외부화 (Extrinsic State) 하고, 공통된 내부 상태를 내부화하여 공유함으로써 객체 수를 최소화한다.

예를 들어 텍스트 렌더링 시스템에서 각 글자의 폰트 스타일 등 공통 속성은 공유하고, 위치 정보 등만 별도로 유지하여 수천 개의 문자 객체를 효율적으로 관리할 수 있다. 메모리 절감, 성능 향상이 필요한 시스템에 효과적이다.

배경

역사적 배경

플라이웨이트 패턴은 1990 년 Paul Calder 와 Mark Linton 에 의해 WYSIWYG 문서 편집기에서 글리프 (Glyph) 정보를 효율적으로 처리하기 위해 최초로 제안되었다. 이후 GoF 에 의해 공식화되어 23 개 디자인 패턴 중 하나로 정립되었다.

기술적 배경

• 메모리 제약: 초기 시스템에서 RAM 용량이 제한적이었던 환경
• 객체지향 프로그래밍의 발전: 객체 기반 설계의 확산과 함께 발생한 메모리 사용량 증가 문제
• 성능 최적화 요구: 대규모 응용프로그램에서의 효율적인 자원 관리 필요성

목적 및 필요성

주요 목적

• 메모리 최적화: 유사한 객체들 간의 공통 데이터 공유를 통한 메모리 사용량 감소
• 성능 향상: 객체 생성 오버헤드 감소로 인한 애플리케이션 성능 개선
• 확장성 보장: 대량의 객체를 다루는 시스템에서의 확장성 확보

필요성

• 대량의 유사한 객체 생성이 필요한 상황
• 메모리 사용량이 시스템 성능에 중요한 영향을 미치는 환경
• 객체 생성 비용이 높은 경우
• 모바일 기기나 임베디드 시스템과 같은 리소스 제약 환경

핵심 개념

Flyweight Pattern은 메모리 사용을 최적화하기 위해 동일한 객체를 공유해서 사용하는 구조적 디자인 패턴이다. 특히, 수많은 유사한 객체가 동시에 존재해야 할 때 사용되며, 각 객체의 공통된 내부 상태 (Intrinsic State) 는 공유하고, 개별적으로 달라지는 외부 상태 (Extrinsic State) 는 외부에서 주입된다.

핵심 원리는 " 공통된 상태를 공유 " 하고, " 변하는 상태만 외부에서 관리 " 함으로써 객체 수를 줄이고 성능을 높이는 것이다.

기본 개념

• 공유 풀 (Flyweight Factory): 공유 가능한 객체들을 관리하는 팩토리이다.
• 메모리 최적화: 동일한 객체를 여러 번 생성하지 않고 공유하여 메모리 사용량을 줄인다.
• 구조적 패턴: 객체 간의 관계를 구조적으로 설계하여, 시스템의 유연성과 확장성을 높인다.

상태 분리 원칙

• 내부 상태 (Intrinsic State): 객체 간에 공유 가능한 불변 상태로, 공통 데이터를 저장한다.
• 외부 상태 (Extrinsic State): 객체마다 고유하게 필요한 상태로, 공유되지 않는다.

메모리 최적화 원리

• 객체 공유: 동일한 고유 상태를 가진 객체들의 인스턴스 재사용
• 상태 분리: 공유 가능한 상태와 개별 상태의 명확한 구분
• 캐싱 메커니즘: 생성된 플라이웨이트 객체의 풀 (Pool) 관리

의도 (Intent)

공유를 통해 대량의 소립 (fine-grained) 객체를 효율적으로 지원하여 메모리 사용을 최소화한다.

다른 이름 (Also Known As)

• 경량 패턴 (Lightweight Pattern)
• 캐시 패턴 (Cache Pattern)

동기 (Motivation / Forces)

• 대량의 유사 객체를 생성해야 할 때, 객체의 불변 상태를 공유해 메모리 사용과 생성 비용을 줄이고자 할 때.

적용 가능성 (Applicability)

• 대량의 객체가 필요하고, 이 객체들이 많은 상태를 공유할 수 있을 때
• 객체 생성 비용이 높거나, 메모리 사용이 중요한 시스템
• 텍스트 에디터, 게임, 그래픽, 데이터베이스 등.

패턴이 해결하고자 하는 설계 문제

• 문제: 동일한 데이터를 가진 객체가 반복 생성되어 메모리 낭비
• 해결: 공유를 통해 메모리 절약

문제를 해결하기 위한 설계 구조와 관계

• 구조: FlyweightFactory 에서 공유 객체 관리
• 관계: Client 는 외부 상태 제공, Flyweight 는 내부 상태 공유

실무 구현 관점

• 공유 가능 데이터 식별: 어떤 데이터가 여러 객체에서 중복될 수 있는지 분석합니다.
• 상태 분리: 내부/외부 상태를 명확히 구분하여 설계합니다.
• 팩토리 활용: Flyweight 객체 생성 및 관리에 팩토리 패턴을 활용합니다.
• 동시성 관리: 멀티스레드 환경에서 상태 공유 시 동기화 문제를 고려해야 합니다.

실무 구현을 위한 핵심 요소

팩토리 관리 (Factory Management)

• Flyweight 객체의 생성과 관리를 담당
• 이미 생성된 객체는 재사용하고, 없을 경우에만 새로 생성
• 싱글톤 패턴과 결합하여 전역 접근점 제공

상태 관리 전략 (State Management Strategy)

• 내재적 상태는 Flyweight 객체 내부에 불변으로 저장
• 외재적 상태는 클라이언트가 메서드 호출 시 매개변수로 전달
• 상태 분리를 통한 메모리 최적화와 객체 재사용성 확보

주요 기능 및 역할

주요 기능

• 객체 공유 관리: 동일한 내재적 상태를 가진 객체들의 공유 관리
• 상태 분리: 내재적 상태와 외재적 상태의 체계적 분리
• 팩토리 기반 객체 생성: 중앙화된 객체 생성 및 관리
• 메모리 최적화: 중복 객체 제거를 통한 메모리 효율성 확보

핵심 역할

• 리소스 절약: 시스템 자원의 효율적 활용
• 성능 최적화: 객체 생성 오버헤드 최소화
• 확장성 지원: 대규모 객체 관리 시스템 구축

특징

구조적 특징

• 공유 가능한 내재적 상태와 컨텍스트별 외재적 상태의 명확한 분리
• 팩토리 패턴과의 결합을 통한 객체 생성 관리
• 불변 객체 (Immutable Object) 특성을 통한 안전한 공유

동작적 특징

• 지연 초기화 (Lazy Initialization) 를 통한 필요 시점 객체 생성
• 캐싱 메커니즘을 통한 객체 재사용
• 클라이언트와 Flyweight 객체 간의 느슨한 결합

핵심 원칙

설계 원칙

• Single Responsibility Principle: 각 Flyweight 는 단일 책임을 가짐
• Open/Closed Principle: 새로운 Flyweight 타입 추가 시 기존 코드 수정 없이 확장 가능
• Dependency Inversion Principle: 클라이언트는 구체적인 Flyweight 가 아닌 인터페이스에 의존

메모리 관리 원칙

• 공유 최대화: 가능한 한 많은 데이터를 공유하여 메모리 사용량 최소화
• 불변성 보장: 내재적 상태의 불변성을 통한 안전한 공유
• 지연 생성: 실제 필요한 시점에만 객체 생성

7.5. 참여자들 간의 상호작용 방식

• Client → FlyweightFactory: 객체 요청
• FlyweightFactory → Flyweight: 객체 생성/반환
• Client → Flyweight: 외부 상태 전달

작동 원리 및 방식

작동 순서

1. 클라이언트 요청: 특정 내재적 상태를 가진 Flyweight 객체 요청
2. 팩토리 검사: 팩토리에서 기존 객체 존재 여부 확인
3. 객체 반환: 기존 객체가 있으면 반환, 없으면 새로 생성 후 반환
4. 상태 전달: 클라이언트가 외재적 상태를 메서드 매개변수로 전달
5. 작업 수행: Flyweight 객체가 내재적 상태와 외재적 상태를 조합하여 작업 수행

작동 방식 다이어그램

classDiagram
    class Flyweight {
        -sharedState
        +operation(extrinsicState)
    }

    class ConcreteFlyweight {
        +operation(extrinsicState)
    }

    class FlyweightFactory {
        -flyweights : Map
        +getFlyweight(key)
    }

    class Client {
        +operation()
    }

    Flyweight <|-- ConcreteFlyweight
    FlyweightFactory --> Flyweight
    Client --> FlyweightFactory
    Client --> Flyweight

설명: 클라이언트는 Factory 를 통해 Flyweight 객체를 얻고, 외부 상태를 주입하여 사용한다.

주요 원리

• 동일한 객체는 한 번만 생성
• 내부/외부 상태 분리
• 팩토리에서 객체 관리

패턴 적용의 결과와 트레이드오프

• 결과: 메모리 절약, 성능 향상
• 트레이드오프: 상태 분리 복잡성, 동시성 문제

상태 분리 원리

graph TD
    A[원본 객체] --> B[내재적 상태<br/>Intrinsic State]
    A --> C[외재적 상태<br/>Extrinsic State]
    B --> D[Flyweight 객체에 저장<br/>공유 가능, 불변]
    C --> E[클라이언트가 관리<br/>컨텍스트별 변경]
    D --> F[메모리 절약]
    E --> F

내재적 상태 (Intrinsic State)

• 여러 객체 간에 공유 가능한 상태
• 컨텍스트에 독립적이고 불변적
• Flyweight 객체 내부에 저장

외재적 상태 (Extrinsic State)

• 각 객체마다 고유한 상태
• 컨텍스트에 의존적이고 가변적
• 클라이언트에서 관리하고 메서드 호출 시 전달

객체 공유 원리

sequenceDiagram
    participant Client
    participant Factory
    participant FlyweightPool
    participant Flyweight

    Client->>Factory: getFlyweight(key)
    Factory->>FlyweightPool: check existing
    alt 기존 객체 존재
        FlyweightPool-->>Factory: return existing
    else 새 객체 필요
        Factory->>Flyweight: create new
        Factory->>FlyweightPool: store new
        FlyweightPool-->>Factory: return new
    end
    Factory-->>Client: return flyweight
    Client->>Flyweight: operation(extrinsicState)

메모리 관리 방식

graph LR
    A[대량의 유사 객체] --> B[상태 분석]
    B --> C[내재적 상태 추출]
    B --> D[외재적 상태 분리]
    C --> E[Flyweight Pool]
    D --> F[Client Context]
    E --> G[메모리 절약]
    F --> G

1

메모리 절약량 = (총 객체 수 × 객체 크기) - (플라이웨이트 수 × 플라이웨이트 크기 + 외부 상태 총 크기)

상태 분리 원리

1
2
3

전체 상태 = 고유 상태 (Intrinsic) ∪ 외부 상태 (Extrinsic)
고유 상태 = 모든 객체 간 공유 가능한 불변 정보
외부 상태 = 컨텍스트별 개별 관리되는 가변 정보

관련 패턴

구조 및 아키텍처

공통된 내부 상태는 캐시된 Flyweight 객체에서 공유되고, 각 호출마다 클라이언트가 외부 상태를 주입한다.

전체 구조

classDiagram
    class Flyweight {
        <<interface>>
        +operation(extrinsicState)
    }
    
    class ConcreteFlyweight {
        -intrinsicState
        +operation(extrinsicState)
    }
    
    class UnsharedConcreteFlyweight {
        -allState
        +operation(extrinsicState)
    }
    
    class FlyweightFactory {
        -flyweights: Map
        +getFlyweight(key): Flyweight
    }
    
    class Client {
        -extrinsicState
        +operation()
    }
    
    Flyweight <|-- ConcreteFlyweight
    Flyweight <|-- UnsharedConcreteFlyweight
    FlyweightFactory --> Flyweight
    Client --> FlyweightFactory
    Client --> Flyweight

구현 기법

• 객체 생성 및 관리: 팩토리 패턴, 캐싱, 객체 풀
• 상태 분리: 불변 객체 설계, 상태 주입 구조, Intrinsic/Extrinsic 분리
• 메모리 최적화: 약한 참조, TTL/LRU, 캐시 정책
• 동시성: 멀티스레드 안전성 확보, 동기화 메커니즘
• 고급 전략: 코드 자동화, 적용 조건 분석

Factory Method 기반 객체 풀링

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

class Font:
    def __init__(self, name):
        self.name = name  # intrinsic 상태

    def render(self, content, size):
        print(f"Rendering '{content}' with font '{self.name}' at size {size}")

class FontFactory:
    _font_pool = {}

    @classmethod
    def get_font(cls, name):
        if name not in cls._font_pool:
            print(f"[Factory] Creating new Font: {name}")
            cls._font_pool[name] = Font(name)
        else:
            print(f"[Factory] Reusing Font: {name}")
        return cls._font_pool[name]

• 설명: 동일 폰트를 재사용하기 위해 Factory 클래스가 객체 생성을 통제

상태 분리: Intrinsic Vs Extrinsic

1
2
3
4
5
6
7

class Character:
    def __init__(self, letter, font):
        self.letter = letter          # 공유 가능한 intrinsic 상태
        self.font = font

    def display(self, x, y, color):   # 개별 extrinsic 상태는 메서드로 전달
        print(f"Display '{self.letter}' in font '{self.font}' at ({x},{y}) with color {color}")

• 설명: 문자와 폰트는 공유, 위치나 색상은 개별 상태로 분리

캐싱 및 해시 기반 객체 풀링

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

class FlyweightFactory:
    def __init__(self):
        self._pool = {}

    def get_flyweight(self, key):
        if key not in self._pool:
            print(f"[Cache] Creating new object for key: {key}")
            self._pool[key] = ConcreteFlyweight(key)
        else:
            print(f"[Cache] Using cached object for key: {key}")
        return self._pool[key]

class ConcreteFlyweight:
    def __init__(self, shared_state):
        self.shared_state = shared_state  # intrinsic 상태

    def operate(self, unique_state):
        print(f"[Flyweight] Shared: {self.shared_state}, Unique: {unique_state}")

• 설명: dict 를 사용한 객체 재사용 로직 구현

약한 참조 기반 캐싱 (실패 사례 포함)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

import weakref

class WeakFlyweightFactory:
    def __init__(self):
        self._pool = weakref.WeakValueDictionary()

    def get(self, key):
        if key not in self._pool:
            print(f"[WeakRef] Creating new: {key}")
            self._pool[key] = ConcreteFlyweight(key)
        return self._pool[key]

• 설명: WeakValueDictionary 는 객체가 참조되지 않으면 GC 가 제거
• 주의: 참조 유지하지 않으면 즉시 GC 대상 → 재사용 불가

Thread-Safe Factory

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

import threading

class ThreadSafeFactory:
    _lock = threading.Lock()
    _pool = {}

    @classmethod
    def get(cls, key):
        with cls._lock:  # 임계 구역 보호
            if key not in cls._pool:
                print(f"[ThreadSafe] Creating: {key}")
                cls._pool[key] = ConcreteFlyweight(key)
            return cls._pool[key]

• 설명: 동시성 환경에서의 안전한 객체 생성 보장

불변 객체 설계

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

class ImmutableFlyweight:
    __slots__ = ['_state']  # 메모리 최적화 및 불변성 의도 명확화

    def __init__(self, state):
        self._state = state

    @property
    def state(self):
        return self._state

    def operate(self, unique):
        print(f"[Immutable] Shared: {self._state}, Unique: {unique}")

• 설명: 내부 상태는 설정 후 변경 불가 → 상태 오염 방지 및 동시성 강화

장점

• Flyweight 의 가장 큰 강점은 메모리 최적화와 성능 향상.
• Factory 패턴 기반의 객체 재사용은 객체 관리의 일관성, 유지보수성, 확장성까지 자연스럽게 제공.
• 특히 대용량 데이터 또는 대규모 UI 렌더링, 게임 엔진, 문서 처리 시스템에서 강력한 장점을 발휘.

단점과 문제점 그리고 해결방안

• 설계 복잡성은 Flyweight 의 대표적인 진입 장벽으로, 상태 모델링 능력이 매우 중요.
• 동시성 이슈와 메모리 관리는 실무에서 반드시 고려되어야 하며, 불변 객체 설계와 캐시 정책 적용이 핵심 해결책.
• 적용 여부 판단도 중요하며, 오히려 성능을 저해하는 오버엔지니어링을 피하기 위한 사전 분석 절차가 필요.

도전 과제

• 상태 분리 설계와 캐시 관리는 가장 빈번한 도전 과제이며, 불변 객체와 LRU 정책이 핵심적인 대응 전략이다.
• 멀티스레드 환경에서는 Concurrent 자료구조와 Lock-Free 설계가 중요하며,
• **실무 성능 개선 효과는 정량적 측정 (프로파일링/벤치마킹)**을 통해 명확히 해야 한다.
• 현대 분산/클라우드 환경에서는 객체 공유 전략이 더욱 복잡해지므로 로컬화 및 분산 캐싱이 효과적이다.

분류 기준에 따른 종류 및 유형

실무 적용 예시

• Flyweight 은 " 공통 속성 " 을 공유하고, " 개별 속성 " 은 외부에서 주입하여 메모리 효율을 극대화함
• 실무에서는 텍스트, 렌더링, GUI, 데이터 시각화, IoT 등 메모리 최적화가 중요한 분야에서 주로 활용
• 공통 리소스를 최대한 분리하고 관리하는 구조 설계가 핵심이며, 팩토리 + 캐시 + 불변 객체 조합이 자주 사용됨

활용 사례

사례 1: 텍스트 에디터 시스템

Microsoft Word 와 같은 텍스트 에디터에서 수천, 수만 개의 문자 객체를 효율적으로 관리해야 하는 상황

시스템 구성:

graph TB
    A[Document Editor] --> B[Character Factory]
    B --> C[Character Pool]
    C --> D[Character A]
    C --> E[Character B]
    C --> F[Character …]
    
    A --> G[Document Context]
    G --> H[Position Info]
    G --> I[Formatting Info]
    G --> J[Style Info]
    
    D --> K[Font Family]
    D --> L[Font Size]
    E --> K
    E --> L

Workflow:

1. 사용자가 문자 입력
2. Character Factory 에서 해당 문자 객체 확인
3. 기존 객체가 있으면 재사용, 없으면 새로 생성
4. Document Context 에서 위치, 스타일 정보 관리
5. 렌더링 시 Flyweight 객체와 외재적 상태 결합

Flyweight Pattern 의 역할:

• 동일한 문자의 중복 생성 방지
• 폰트 정보와 같은 공통 속성 공유
• 메모리 사용량 최적화

Pattern 적용 전후 차이점:

• 적용 전: 각 문자마다 별도 객체 생성, 메모리 사용량 급증
• 적용 후: 문자 종류만큼만 객체 생성, 메모리 사용량 90% 감소

사례 2: 멀티플레이어 게임의 총알 시스템

대규모 멀티플레이어 슈팅 게임에서 수천 개의 총알 객체가 동시에 화면에 존재하는 상황

시스템 구성

1
2
3
4
5
6
7
8

Game Engine
├── BulletFactory (플라이웨이트 팩토리)
├── BulletType (플라이웨이트 인터페이스)
│   ├── PistolBullet (구체적 플라이웨이트)
│   ├── RifleBullet (구체적 플라이웨이트)
│   └── SniperBullet (구체적 플라이웨이트)
├── BulletContext (컨텍스트)
└── GameObjectManager (클라이언트)

구성 다이어그램

1
2
3
4
5
6
7

Player → GameObjectManager → BulletFactory
                ↓
            BulletType (공유 객체)
                ↓
        BulletContext (개별 상태: 위치, 속도, 방향)
                ↓
            Rendering Engine

Workflow:

1. 총알 발사 요청: 플레이어가 발사 버튼 클릭
2. 팩토리 조회: GameObjectManager 가 BulletFactory 에 해당 총알 타입 요청
3. 플라이웨이트 반환: 기존 BulletType 객체 반환 또는 새로 생성
4. 컨텍스트 생성: 총알의 위치, 속도, 방향 등 외부 상태로 BulletContext 생성
5. 게임 루프 처리: 매 프레임마다 BulletContext 업데이트 및 렌더링

담당 역할:

• BulletFactory: 총알 타입별 플라이웨이트 객체 관리 (메모리 3 개 객체만 유지)
• BulletType: 총알의 공통 속성 (데미지, 스프라이트, 사운드) 저장
• BulletContext: 개별 총알의 동적 상태 (위치, 속도, 생존시간) 관리
• 메모리 효과: 10,000 개 총알 × 각 100KB → 3 개 플라이웨이트 × 50KB + 10,000 개 컨텍스트 × 5KB = 200KB (99% 절약)

구현 예시

Python

 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

class TreeType:
    def __init__(self, name, color, texture):
        self.name = name
        self.color = color
        self.texture = texture

    def draw(self, x, y):
        print(f"Drawing {self.name} at ({x},{y}) with {self.color} and {self.texture}")

class TreeFactory:
    _tree_types = {}

    @classmethod
    def get_tree_type(cls, name, color, texture):
        key = (name, color, texture)
        if key not in cls._tree_types:
            print("Creating new TreeType")
            cls._tree_types[key] = TreeType(name, color, texture)
        return cls._tree_types[key]

class Tree:
    def __init__(self, x, y, tree_type):
        self.x = x
        self.y = y
        self.tree_type = tree_type

    def draw(self):
        self.tree_type.draw(self.x, self.y)

# 사용 예시
forest = []
tree_type = TreeFactory.get_tree_type("Oak", "Green", "Rough")
forest.append(Tree(10, 20, tree_type))
forest.append(Tree(30, 40, tree_type))

for tree in forest:
    tree.draw()

Python: 문서 컨텍스트 관리

 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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

from abc import ABC, abstractmethod
from typing import Dict, Optional

class Character(ABC):
    """Flyweight 인터페이스 - 문자 객체의 공통 인터페이스"""
    
    @abstractmethod
    def render(self, position_x: int, position_y: int, font_size: int, color: str) -> None:
        """문자 렌더링 - 외재적 상태를 매개변수로 받음"""
        pass

class ConcreteCharacter(Character):
    """구체적인 Flyweight - 공유 가능한 문자 객체"""
    
    def __init__(self, symbol: str, font_family: str):
        # 내재적 상태 - 모든 인스턴스에서 공유됨
        self._symbol = symbol
        self._font_family = font_family
    
    def render(self, position_x: int, position_y: int, font_size: int, color: str) -> None:
        """외재적 상태와 내재적 상태를 결합하여 문자 렌더링"""
        print(f"문자 '{self._symbol}' 렌더링:")
        print(f"  위치: ({position_x}, {position_y})")
        print(f"  폰트: {self._font_family}, 크기: {font_size}")
        print(f"  색상: {color}")

class CharacterFactory:
    """Flyweight Factory - 문자 객체 생성 및 관리"""
    
    _characters: Dict[str, Character] = {}
    
    @classmethod
    def get_character(cls, symbol: str, font_family: str = "Arial") -> Character:
        """문자 객체 획득 - 기존 객체 재사용 또는 새로 생성"""
        key = f"{symbol}_{font_family}"
        
        if key not in cls._characters:
            print(f"새로운 문자 객체 생성: {symbol} ({font_family})")
            cls._characters[key] = ConcreteCharacter(symbol, font_family)
        else:
            print(f"기존 문자 객체 재사용: {symbol} ({font_family})")
        
        return cls._characters[key]
    
    @classmethod
    def get_created_characters_count(cls) -> int:
        """생성된 문자 객체 수 반환"""
        return len(cls._characters)

class Document:
    """클라이언트 - 문서 컨텍스트 관리"""
    
    def __init__(self):
        self._characters = []  # 문자와 외재적 상태 저장
    
    def add_character(self, symbol: str, x: int, y: int, 
                     font_size: int, color: str, font_family: str = "Arial"):
        """문자 추가 - Flyweight 객체와 외재적 상태 관리"""
        character = CharacterFactory.get_character(symbol, font_family)
        self._characters.append({
            'character': character,
            'x': x, 'y': y,
            'font_size': font_size,
            'color': color
        })
    
    def render_document(self):
        """문서 전체 렌더링"""
        print("\n=== 문서 렌더링 시작 ===")
        for char_data in self._characters:
            char_data['character'].render(
                char_data['x'], char_data['y'],
                char_data['font_size'], char_data['color']
            )
        print(f"\n총 생성된 Character 객체 수: {CharacterFactory.get_created_characters_count()}")
        print(f"총 문서 내 문자 수: {len(self._characters)}")

# 사용 예시
def main():
    document = Document()
    
    # "HELLO" 문자열 추가 - 같은 문자는 객체 재사용
    word = "HELLO"
    for i, symbol in enumerate(word):
        document.add_character(
            symbol=symbol,
            x=i * 20, y=100,
            font_size=12, color="black"
        )
    
    # 동일한 문자 'L' 다시 사용 - 기존 객체 재사용됨
    document.add_character('L', 150, 100, 16, "red")
    
    document.render_document()

if __name__ == "__main__":
    main()

실무에서 효과적으로 적용하기 위한 고려사항 및 주의할 점

• " 공유 가능한 객체인가?" 를 기준으로 상태 분석이 가장 우선되어야 하며,
• 팩토리는 단일 책임을 갖되 동시성과 캐시 관리까지 효율적으로 수행해야 함
• 불변성 보장과 외부 상태 관리는 실무에서의 안정성과 유지보수성을 좌우
• 정량적 측정과 테스트 자동화를 통해 적용 효과를 검증해야 함

테스트 전략

• 동일 객체 반환 여부 확인
• 외부 상태 전달 시 정상 동작 확인

리팩토링 전략

• 중복 객체 생성 코드를 FlyweightFactory 로 이동
• 상태 분리 명확화

활용 시 흔한 실수

• 내부/외부 상태 구분 불명확
• 동시성 문제 무시

성능을 최적화하기 위한 고려사항 및 주의할 점

• 공유 객체 수가 많아질수록 메모리 최적화와 동시성 제어의 균형이 중요
• 팩토리 설계는 성능의 핵심 → 캐시, 해시 함수, 동기화 전략을 정교하게 설계
• I/O 또는 네트워크 환경에서는 최소 데이터 전송 → Intrinsic 만 공유
• 모든 최적화는 사전/사후 측정 기반으로 이루어져야 함 → 프로파일링과 모니터링 필수

주제와 관련하여 주목할 내용

반드시 학습해야할 내용

용어 정리

참고 및 출처

공식 및 이론 중심 자료

• Flyweight Pattern - Refactoring Guru
• Flyweight Design Pattern - GeeksforGeeks
• Flyweight Pattern - Wikipedia
• Flyweight Design Pattern - TutorialsPoint
• Flyweight Design Pattern - HowToDoInJava
• Flyweight Pattern (Java Design Patterns)

실무 사례 및 블로그 기반 자료

• Flyweight Pattern in Java - Baeldung
• Stack Abuse - Flyweight Pattern in Python
• Python101 - 플라이웨이트 패턴 파이썬 예제
• velog - 플라이웨이트(경량) 패턴
• Inpa Dev - 플라이웨이트 패턴 완벽 마스터하기