Modelul Flyweight în Go

Ce este

Modelul Flyweight economisește memorie atunci când un program ține mii de obiecte asemănătoare: partea grea, comună, este stocată o singură dată și referită peste tot, iar fiecare obiect păstrează doar mica lui parte unică.

O pădure de 10.000 de copaci nu are nevoie de 10.000 de texturi — are nevoie de 2 tipuri de copaci și de 10.000 de înregistrări minuscule (x, y, tip).

Exemplu: o pădure cu tipuri partajate

GetKind() distribuie obiecte de tip partajate, creând fiecare obiect doar la prima cerere. Fiecare copac stochează doar o poziție și un pointer.

Mulți copaci, puține tipuri

Patru copaci, dar „creare tip” se afișează doar de două ori — stejarul și pinul există câte o singură dată, oricât de mare ar deveni pădurea.

Scrie un program Go cu modelul Flyweight: un TreeKind greu (nume, textură) stocat o singură dată pentru fiecare tip într-un map, în spatele unei funcții GetKind care afișează un mesaj când creează un tip, și structuri Tree ușoare care păstrează doar o poziție și un pointer către tipul lor. Plantează patru copaci de două tipuri și afișează câți copaci există față de câte tipuri au fost stocate.

> Ieșire: program Go și rezultatul capturat

Prompt

Scrie un program Go cu modelul Flyweight: un TreeKind greu (nume, textură) stocat o singură dată pentru fiecare tip într-un map, în spatele unei funcții GetKind care afișează un mesaj când creează un tip, și structuri Tree ușoare care păstrează doar o poziție și un pointer către tipul lor. Plantează patru copaci de două tipuri și afișează câți copaci există față de câte tipuri au fost stocate.

Ieșire: program Go și rezultatul capturat

package main

import "fmt"

// Partea grea, partajată — creată o singură dată pentru fiecare tip.
type TreeKind struct {
  name    string
  texture string
}

var kinds = map[string]*TreeKind{}

func GetKind(name string) *TreeKind {
  if k, ok := kinds[name]; ok {
    return k
  }
  fmt.Println("creare tip:", name)
  k := &TreeKind{name: name, texture: name + ".png"}
  kinds[name] = k
  return k
}

// Partea ușoară, specifică fiecărui copac: o poziție și un pointer.
type Tree struct {
  x, y int
  kind *TreeKind
}

func main() {
  forest := []Tree{
    {x: 1, y: 2, kind: GetKind("stejar")},
    {x: 3, y: 4, kind: GetKind("pin")},
    {x: 5, y: 6, kind: GetKind("stejar")},
    {x: 7, y: 8, kind: GetKind("pin")},
  }

  fmt.Println("copaci plantați:", len(forest))
  fmt.Println("tipuri stocate: ", len(kinds))
}

Când să îl folosești

Folosește-l atunci când măsurătorile arată probleme de memorie provocate de multe obiecte care repetă date grele — dale de hartă, glife, particule, stiluri păstrate în cache.

Renunță la el sub câteva mii de obiecte sau când partea comună este mică. Este un model de optimizare: fără problema de memorie, aduce doar complexitate.

Avantaje și dezavantaje

Avantaje: economii mari de memorie la scară largă; datele comune se actualizează într-un singur loc.

Dezavantaje: obiectele partajate trebuie tratate ca fiind doar pentru citire — o singură scriere neatentă schimbă „fiecare stejar din pădure”; împărțirea în parte comună și parte unică complică modelul.