[디자인 패턴]Flyweight pattern 총정리

flyweight pattern

---

1. Flyweight

Fly(가벼운) + Weight(무게)를 뜻하며, 복싱의 체급에서 유래되었다.

모든 객체를 일일히 인스턴스화 하지않고 재사용할수 있는 객체는 재사용함으로써 메모리를 가볍게 만든다는 의미로서 쓰인다고 보면 된다.

⇒ 가볍게 만든다!

공유된 자원과 그렇지 않은 자원의 사용량 차이

 

 

2. Flyweight 패턴 구조

Flyweight : 경량 객체를 묶는 인터페이스
ConcreteFlyweight : 공유 가능하여 재사용되는 객체(intrinsic state)
UnsahredConcreteFlyweight: 공유 불가능한 객체 (extrinsic state)
FlyweightFactory : 경량 객체를 만드는 공장 역할과 캐시 역할을 겸비하는 Flyweight 객체 관리 클래스
 - GetFlyweight() 메서드는 팩토리 메서드 역할을 한다고 보면 된다.만일 객체가 메모리에 존재하면 그대로 가져와 반환하고, 없다면 새로 생성해 반환한다
Client : 클라이언트는 FlyweightFactory를 통해 Flyweight 타입의 객체를 얻어 사용한다.

 

3. Flyweight pattern 에서 주의할 점

보다시피 구현 객체의 상태가 중요하다.

intrinsic 와 extrinsic 상태

✅ intrinsic('고유한, 본질적인’)한 객체 : 장소나 상황에 의존하지 않기 때문에 값이 고정되어 공유할 수 있는 객체

      extrinsic('외적인, 비본질적인’)한 객체 : 장소나 상황에 의존하기 때문에 매번 값이 바뀌어 공유할 수 없는 객체

객체들의 상태를 잘 분리해서 적용해야한다.

a. 폭탄 피하기 게임 예제

폭탄 각각은 하나의 객체

• 폭탄 객체들을 일일히 new 를 통해 인스턴스화하면?
  • 객체를 생성 할때마다 메모리를 차지하게 되어 게임이 무거워질 것
  • 어차피 떨어지는 폭탄 객체의 생김새는 모두 같기 때문에 이를 계속 생성하는 것은 중복이다.
• 폭탄을 플라이웨이트로 처리함으로써 폭탄 인스턴스는 하나만 만들고 공유하는 방식으로 화면에 뿌리면 된다.

☠️ 주의점!

폭탄 예제에서 intrinsic 상태정보와 extrinsic 상태정보를 분리해서 생각해보자.

폭탄이 갖고 있는 정보 목록은 다음과 같다.

1. 폭탄 모양
2. 폭탄 색깔
3. 폭탄 x, y 좌표 위치

여기서 1번 2번은 폭탄의 본질적인 고유한 상태를 나타내기 때문에 여러곳에 공유가 가능하다.

반면, 위치값은 실시간으로 변화하기 때문에 이를 캐시하여 공유할 수는 없다.

이를 flyweight pattern에 적용해보자면,

ConcreteFlyweight객체에는 고정적 정보인 1,2번이 포함되게 될 것이고,

UnsharedConcreteFlyweight객체에는 비 고정적 정보인 3번이 포함되게 될 것이다.

그리고 이 두 폭탄 객체들을 FlyweightFactory가 생성하고 관리하게 되는 것이다.

4. 특징

a. 적용시기

• 어플리케이션에 의해 생성되는 객체의 수가 많아 저장 비용이 높아질 때
• 생성된 객체가 오래도록 메모리에 상주하며 사용되는 횟수가 많을때
• 공통적인 인스턴스를 많이 생성하는 로직이 포함된 경우
• 임베디드와 같이 메모리를 최소한으로 사용해야하는 경우에 활용 ⇒ 애초에 허락된 자원의 양 자체가 적다

b. 장점

• 어플리케이션에서 사용하는 메모리를 줄일 수 있다.
• 프로그램 속도를 개선할 수 있다.
  • new로 인스턴스화 하면 데이터가 생성되고 메모리에 적재되는 아주 약간의 시간이 소요된다.
  • 객체를 공유하면 인스턴스를 가져오기만 하면 되기 때문에 메모리 뿐만 아니라 속도도 향상시킬 수 있게 되는 것이다.

c. 단점

• 코드의 킹잡성 증가

 

 

5. 마인크래프트에 나무심기 예제

마인크래프트에 숲을 구현하기 위해서 지형(Terrain)에 나무 객체들을 심으려고 한다.

나무의 종류

나무 객체에 필요한 데이터는 다음과 같다.

1. 나무 종류
2. 줄기, 가지, 잎의 형태를 나타내는 폴리곤 메시 (mesh) ⇒ 형태 관련
3. 나무 껍질 텍스쳐 (texture) ⇒ 형태 관련
4. 입사귀 텍스쳐 (texture) ⇒ 형태 관련
5. 숲에서의 위치 매개변수

No Clean Code

작은 상자에 들어있는 내용은 모든 나무가 동일하다.

Memory.java : 메모리 사용량 체크용 클래스

class Memory {
    public static long size = 0; // 메모리 사용량

    public static void print() {
        System.out.println("총 메모리 사용량 : " + Memory.size + "MB");
    }
}

Tree.java : Tree 객체 클래스

class Tree {
    long objSize = 100; // 100MB
    String type; // 나무 종류
    Object mesh; // 메쉬
    Object texture; // 나무 껍질 + 잎사귀 텍스쳐
    // 위치 변수
    double position_x;
    double position_y;

    public Tree(String type, Object mesh, Object texture, double position_x, double position_y) {
        this.type = type;
        this.mesh = mesh;
        this.texture = texture;
        this.position_x = position_x;
        this.position_y = position_y;

        // 나무 객체를 생성하였으니 메모리 사용 크기 증가
        Memory.size +=  this.objSize;
    }
}

Terrain.java : 지형 클래스, 나무를 생성하는 클라이언트 객체

// Client
class Terrain {
    // 지형 타일 크기
    static final int CANVAS_SIZE = 10000;

    // 나무를 렌더링
    public void render(String type, Object mesh, Object texture, double position_x, double position_y) {
        // 나무를 지형에 생성
        Tree tree = new Tree(
                type, // 나무 종류
                mesh, // mesh
                texture, // texture
                Math.random() * CANVAS_SIZE, // position_x
                Math.random() * CANVAS_SIZE // position_y
        );
        System.out.println("x:" + tree.position_x + " y:" + tree.position_y + " 위치에 " + type + " 나무 생성 완료");
    }
}

main

public static void main(String[] args) {
    // 지형 생성
    Terrain terrain = new Terrain();

    // 지형에 Oak 나무 5 그루 생성
    for (int i = 0; i < 5; i++) {
        terrain.render(
                "Oak", // type
                new Object(), // mesh
                new Object(), // texture
                Math.random() * Terrain.CANVAS_SIZE, // position_x
                Math.random() * Terrain.CANVAS_SIZE // position_y
        );
    }

    // 지형에 Acacia 나무 5 그루 생성
    for (int i = 0; i < 5; i++) {
        terrain.render(
                "Acacia", // type
                new Object(), // mesh
                new Object(), // texture
                Math.random() * Terrain.CANVAS_SIZE, // position_x
                Math.random() * Terrain.CANVAS_SIZE // position_y
        );
    }

    // 지형에 Jungle 나무 5 그루 생성
    for (int i = 0; i < 5; i++) {
        terrain.render(
                "Jungle", // type
                new Object(), // mesh
                new Object(), // texture
                Math.random() * Terrain.CANVAS_SIZE, // position_x
                Math.random() * Terrain.CANVAS_SIZE // position_y
        );
    }

    // 총 메모리 사용률 출력
    Memory.print();
}

각 세종류의 나무를 5개씩 100mb를 곱하면 총 1500mb 메모리가 사용되게 되는 것.

Clean Code → Flyweight pattern 적용

최적화의 핵심은 나무가 수백 그루 넘게 있는다 해도 대부분 비슷하게 보인다는 것이다.

즉, 나무를 생성하는데 사용된 mesh, texture를 재사용하여 표현해도 어차피 같은 나무이니 문제가 없는 것이다.

따라서 공통으로 사용될 모델 데이터, 실시간으로 변하는 위치 매개변수를 분리하여 객체를 구성한다.

이렇게 되면 지형에서 나무를 구현할 때 나무 모델 인스턴스 하나를 공유받고 위치 매개변수만 다르게 설정해주면 메모리 사용량을 절반 이상 줄일 수 있을 것이다. ⇒ 나무가 많으면 많을 수록 절약된다.

• 쉽게 말해, 실시간으로 변하는 위치값보다 나무를 표현하는 메시, 잎사귀 등의 값은 실시간으로 변할 필요없이 재사용해도 상관없다는 거다.

1. intrinsic 객체와 extrinsic 객체 분리하기

마크 게임 내에서 똑같은 메시와 나무껍질 텍스쳐를 일일히 여러번 메모리에 올릴 이유가 없기 때문에 공유되는 나무 모델 객체를 기존 Tree 클래스에서 따로 빼준다.

instrinsic : mesh, texture

extrinsic : position 좌표

TreeModel.java : 불변객체

// ConcreteFlyweight - 플라이웨이트 객체는 불변성을 가져야한다. 변경되면 모든 것에 영향을 주기 때문이다.
final class TreeModel { // final 을 통해 불변 객체로 만들어줌
    // 메시, 텍스쳐 총 사이즈
    long objSize = 90; // 90MB

    String type; // 나무 종류
    Object mesh; // 메쉬
    Object texture; // 나무 껍질 + 잎사귀 텍스쳐

    public TreeModel(String type, Object mesh, Object texture) {
        this.type = type;
        this.mesh = mesh;
        this.texture = texture;

        // 나무 객체를 생성하여 메모리에 적재했으니 메모리 사용 크기 증가
        Memory.size += this.objSize;
    }
}

Tree.java : 가변 객체

// UnsahredConcreteFlyweight
class Tree {
    // 죄표값과 나무 모델 참조 객체 크기를 합친 사이즈
    long objSize = 10; // 10MB

    // 위치 변수
    double position_x;
    double position_y;

    // 나무 모델
    TreeModel model; // 합성을 통해 관계 맺어줌

    public Tree(TreeModel model, double position_x, double position_y) {
        this.model = model;
        this.position_x = position_x;
        this.position_y = position_y;

        // 나무 객체를 생성하였으니 메모리 사용 크기 증가
        Memory.size +=  this.objSize;
    }
}

2. Flyweight 팩토리 만들기

나무 모델 객체에 Flyweight를 적용 했으니 이를 생성 및 관리할 FlyweightFactory 클래스를 만든다.

✅ 플라이웨이트 팩토리의 핵심

• Flyweight Pool : HashMap 컬렉션을 통해 키(key) 와 나무 모델 객체를 저장하는 캐시 저장소 역할
• getInstance 메서드 : Pool에 가져오고자 하는 객체가 있는지 검사를 하여 있으면 그대로 반환, 없으면 새로 생성

// FlyweightFactory
class TreeModelFactory {
    // Flyweight Pool - TreeModel 객체들을 Map으로 등록하여 캐싱
    private static final Map<String, TreeModel> cache = new HashMap<>(); // static final 이라 Thread-Safe 함

    // static factory method
    public static TreeModel getInstance(String key) {
        // 만약 캐시 되어 있다면
        if(cache.containsKey(key)) {
            return cache.get(key); // 그대로 가져와 반환
        } else {
            // 캐시 되어있지 않으면 나무 모델 객체를 새로 생성하고 반환
            TreeModel model = new TreeModel(
                    key,
                    new Object(),
                    new Object()
            );
            System.out.println("-- 나무 모델 객체 새로 생성 완료 --");

            // 캐시에 적재
            cache.put(key, model);

            return model;
        }
    }
}

3. Client 최적화

기존 Terrian 클래스의 render() 메서드는 단순하게 사용자로부터 매개변수를 받아 그대로 tree객체를 생성했다.

그러나 지금 기존 Tree객체를 따로 TreeModel로 나누고, TreeModelFactory까지 생성했으니 이를 이용하는 클라이언트 코드를 최적화 해주어야한다.

✅ Flyweight를 이용한 최적화 작업

1. 먼저 TreeModel에서 공유되고 있는 나무 모델 객체를 가져온다. (캐시에 없다면 새로 생성)
2. 가져온 나무 모델과 좌표값을 이용해 나무 객체를 새로 생성한다.

공유 객체를 가져와 사용함으로써 쓸데없는 mesh 및 texture 낭비를 방지했다.

Terrain.java

// Client
class Terrain {
    // 지형 타일 크기
    static final int CANVAS_SIZE = 10000;

    // 나무를 렌더링
    public void render(String type, double position_x, double position_y) {
        // 1. 캐시 되어 있는 나무 모델 객체 가져오기
        TreeModel model = TreeModelFactory.getInstance(type);

        // 2. 재사용한 나무 모델 객체와 변화하는 속성인 좌표값으로 나무 생성
        Tree tree = new Tree(model, position_x, position_y);

        System.out.println("x:" + tree.position_x + " y:" + tree.position_y + " 위치에 " + type + " 나무 생성 완료");
    }
}

main

public static void main(String[] args) {
    // 지형 생성
    Terrain terrain = new Terrain();

    // 지형에 Oak 나무 5 그루 생성
    for (int i = 0; i < 5; i++) {
        terrain.render(
                "Oak", // type
                Math.random() * Terrain.CANVAS_SIZE, // position_x
                Math.random() * Terrain.CANVAS_SIZE // position_y
        );
    }

    // 지형에 Acacia 나무 5 그루 생성
    for (int i = 0; i < 5; i++) {
        terrain.render(
                "Acacia", // type
                Math.random() * Terrain.CANVAS_SIZE, // position_x
                Math.random() * Terrain.CANVAS_SIZE // position_y
        );
    }

    // 지형에 Jungle 나무 5 그루 생성
    for (int i = 0; i < 5; i++) {
        terrain.render(
                "Jungle", // type
                Math.random() * Terrain.CANVAS_SIZE, // position_x
                Math.random() * Terrain.CANVAS_SIZE // position_y
        );
    }

    // 총 메모리 사용률 출력
    Memory.print();
}

패턴 적용 전에는 1500mb 메모리 사용량이 들어갔으나, 패턴 적용 후에는 420mb로 메모리 사용량이 확 줄어들었다.

전에는 계속 나무를 생성했던 반면에, 나무 모델을 따로 플라이웨이트로 분리함으로써 중복된 값들을 공유 시켜 메모리를 아꼈다.

이처럼 공유할 수 있는 intrinsic 상태의 데이터를 분리하여 캐싱함으로써 프로그램을 최적화하는 것이 중요하다.

주의사항 - GC

우리가 구현한 예제에서는 TreeModelFactory에서 HashMap을 이용해 TreeModel의 인스턴스를 캐싱하여 관리했다.

이처럼 “인스턴스를 관리”하는 기능을 자바 프로그래밍에서 구현하여 사용할 때에는 반드시!! “관리되고 있는 인스턴스는 GC(Garbage Collection) 처리되지 않는다”는 점을 주의해야한다.

그런데 어찌보면 당연한 이치이다. 인스턴스를 관리한다는 것 자체가 메모리에 두고 내가 공유할 것이라고 해놨는데 이걸 GC에서 자동으로 처리해주는게 앞뒤가 맞지 않는다.

즉 이럴 때에는 나무를 모두 렌더링을 완료해서 더이상 나무를 생성할 일이 없다면 반드시 TreeModelFactory에 잔존해있는 Flyweight Pool을 비워줄 필요가 있는 것이다.

그래야 인스턴스에 대한 참조를 잃은 TreeModel 인스턴스들이 GC에 의해 메모리 청소가 되게 된다.

구체적으로 HashMap에서 해당 인스턴스를 포함하는 엔트리를 삭제시켜버리면 인스턴스에 대한 참조를 없앨 수 있다.

 

 

6. 실무에서 만나보자

String Constant Pool

String Constant Pool 개념이 바로 Flyweight Pool 개념이다.
자바는 String 데이터에 대해 별도로 string constant pool 영역에 적재한다.
그래서 같은 문자열 데이터 다시 사용될때 pool을 검사해 있다면 이를 공유한다.
만일 pool에 없다면 새로 메모리를 할당하여 pool에 등록한 후 재사용한다.
즉, String 클래스는 Flyweight 패턴을 통해 리터럴 문자열 데이터에 대한 캐싱을 하고 있는 것이다.
또한 String 클래스는 불변(immutable) 객체 특성을 가지고 있다.

// 문자열 리터럴은 String Pool에 저장되는 Flyweight 패턴을 이용한다.
String str1 = "Hello"; 
String str2 = "Hello";

// 두 주소값이 같다는 말은 메모리에 하나의 데이터만 적재되고 이를 공유하고 있다는 반증
System.out.println(str1 == str2); // true

// new 연산자를 이용한 방식은 Flyweight 패턴을 적용하지 않는다.
String str3 = new String("Hello"); 
String str4 = new String("Hello");

// 서로 다른 힙 메모리에 저장된 데이터이니 두 주솟값은 다르다
System.out.println(str3 == str4); // false

Integer의 valueOf()

자바의 Interger 클래스의valueOf() 메서드는 정적 팩토리 메서드로서,valueOf() 메서드를 통해 값을 할당하면 Flyweight 패턴을 통해 캐시되게 된다.
valueOf() 메소드가 호출 되었을 때 요청된 Integer 값이 -128 ~ 127 범위의 정수라면 캐싱을 이용하도록 설계 되어있다.
Integer 뿐만 아니라 Double이나 Boolean 같은 Wrapper 클래스들도 마찬가지로 적용된다.

// valueOf 정적 팩토리 메서드로 수를 등록하면 캐시됨
// auto boxing으로 Integer i1 = 100; 으로 선언하여도 똑같음
Integer i1 = Integer.valueOf(100); 
Integer i2 = Integer.valueOf(100);

System.out.println(i1 == i2); // true

// 생성자로 수를 등록하면 캐시 안됨
Integer i3 = new Integer(100);
Integer i4 = new Integer(100);

System.out.println(i3 == i4); // false

// -128 ~ 127 는 캐시 됨
Integer i1 = Integer.valueOf(100);
Integer i2 = Integer.valueOf(100);

System.out.println(i1 == i2); // true

// -128 ~ 127 를 넘어선 수는 캐시 안됨
Integer i3 = Integer.valueOf(1000);
Integer i4 = Integer.valueOf(1000);

System.out.println(i3 == i4); // false

 

 

7. 아니 근데 이거 또 어디서 많이 듣지 않았나?

싱글톤 패턴도 객체 하나만 생성하고 활용하는 패턴이라고 했었다.

차이점은 인스턴스 생성 제한을 어디서 제어하느냐의 차이이다.

싱글톤 패턴은 우리가 앞서 공부했다시피 여러 방식으로 클래스 자체에서 인스턴스 생성을 1개로 제한하는 것을 배웠다.

그러나 플라이웨이트 패턴은 싱글톤으로 되어있지 않은 클래스를(인스턴스 생성 자체는 여러개 할 수 있음) 팩토리에서 생성과 관리를 하는 것이다.

나무예제에서 살펴보면 불변 객체인 TreeModel클래스 자체가 싱글톤으로 되어있다면 하나의 mesh , texture 값만 가질 수 있게 될 것이다.

그러나 singleton 설명할 때도 알려줬던 DBCP처럼 여기서 팩토리 풀 자체는 싱글톤으로 관리될 수 있을 것이다.

 

출처 : https://inpa.tistory.com/entry/GOF-%F0%9F%92%A0-Flyweight-%ED%8C%A8%ED%84%B4-%EC%A0%9C%EB%8C%80%EB%A1%9C-%EB%B0%B0%EC%9B%8C%EB%B3%B4%EC%9E%90