Flyweight: compartir para ahorrar memoria

  • Lección 17 de 32
  • 10 min
  • Inicial
  • 12 pasos

Un juego dibuja un bosque y cada árbol carga su propia textura. Vas a separar lo que se repite de lo que cambia, compartirlo con una fábrica y ver qué pagas a cambio.

Copias de los datos de especie
3
10.000 árbolestreeType()Integer.valueOftreeType()oakInteger127malla +materialoakpinepinebirchbirchtextura copiada en cada árbolCada árbol con todoclass Tree {▸species = "oak";▸texture = load("oak.png");constructor(public x: number,public y: number) {}}2 de 4 campos se repitenLos campos de un árbolspecies"oak"intrínsecotextureoak.pngintrínsecox4extrínsecoy0extrínsecocompartido por milesx, y + una referenciaDos tipostype TreeType = Readonly<{species: string; texture: Image }>;type Tree = {x: number; y: number;type: TreeType };treeType("oak")ya existe: el mismo objetoLa fábrica con cachéfunction treeType(species: string) {▸let t = cache.get(species);if (!t) {t = Object.freeze(load(species));cache.set(species, t);}▸return t;}treeType("birch")nuevo: se guarda una vezSi no está, se crea una vezfunction treeType(species: string) {let t = cache.get(species);▸if (!t) {▸t = Object.freeze(load(species));▸cache.set(species, t);}return t;}x, y: de cada árboltextura: compartidaAl dibujar se juntanfor (const t of forest) {▸draw(t.type.texture, t.x, t.y);}// textura compartida, posición propiainmutableUn cambio para todosconst oak = treeType("oak");▸oak.texture = autumn;// modo estricto: TypeError// el objeto está congeladocaché de partes, no de resultadosTres ideas equivocadas«es cualquier caché»comparte partes inmutables«siempre ahorra memoria»con pocos objetos cuesta más«== compara valores»solo con objetos de la cachéa == b: el mismo objeto128: sin garantíaLa caché de IntegerInteger a = Integer.valueOf(127);Integer b = Integer.valueOf(127);a == b; // trueInteger c = Integer.valueOf(128);Integer d = Integer.valueOf(128);▸c == d; // puede ser falsec.equals(d); // truecolor y escala por instanciaDónde te lo cruzasJava String.intern()un objeto por texto igualPython sys.interncompara claves por punteroUnity GPU instancinguna malla, muchas instancias¿crece sin límite?No lo uses si…miles, no millonesel ahorro no compensalos datos cambian por objetono hay qué compartirno mediste la memoriano sabes si ganasla caché no tiene límitecrece para siempreun objeto por especieFlyweight en una tablaproblemamiles de copias igualessolucióncompartir la parte que se repitequién reparteuna fábrica con cachéreglalo compartido es inmutableno lo usessin medir la memoria
  • petición
  • respuesta
  • petición fallida

Paso 1 de 12

Problema

Diez mil árboles, diez mil texturas

Un juego dibuja un bosque. Cada Tree guarda su especie, su textura y su posición. Con 10.000 árboles (valor de ejemplo) hay 10.000 objetos completos.

Pero solo hay dos especies. La textura de un roble es la misma en todos los robles, y aun así se carga una vez por árbol. La memoria se va en copiar lo mismo una y otra vez.

Paso 2 de 12

Concepto

Lo que se repite y lo que no

Mira los cuatro campos de un árbol. species y texture valen lo mismo en miles de árboles: es el estado intrínseco, el que se puede compartir.

x e y cambian en cada árbol: es el estado extrínseco, el de cada uso. Flyweight empieza por esta separación; sin ella no hay nada que compartir.

Qué cambió

  • species, texture: compartidos
  • x, y: de cada árbol

Paso 3 de 12

Solución

Dos objetos para todo el bosque

Movemos la parte intrínseca a un tipo propio, TreeType, y creamos un objeto por especie: uno para el roble y otro para el pino.

Cada Tree queda con x, y y una referencia a su TreeType. Los 10.000 árboles apuntan a solo 2 objetos de especie. Ese objeto compartido es el flyweight («peso mosca»).

Qué cambió

  • TreeType (2 objetos)
  • 9.998 copias de especie y textura

Paso 4 de 12

Técnica

Una fábrica reparte los objetos compartidos

¿Quién garantiza que no aparezca un segundo roble? Una fábrica con caché: treeType(species) busca en un Map y, si la especie ya existe, devuelve el mismo objeto.

El bosque pide treeType("oak") y recibe el roble que ya estaba. No se crea nada nuevo. Ningún otro código crea un TreeType: solo la fábrica.

Paso 5 de 12

Técnica

Una especie nueva se crea una sola vez

Ahora el bosque pide treeType("birch"). El Map no tiene abedul, así que la fábrica lo crea, lo congela con Object.freeze y lo guarda.

La próxima vez que alguien pida "birch" recibirá ese mismo objeto. Hay 3 objetos de especie, aunque el bosque tenga miles de abedules.

Qué cambió

  • birch en la caché

Paso 6 de 12

Técnica

Lo que cambia viaja aparte

Para dibujar, el código junta las dos partes en el momento: la textura sale del objeto compartido y la posición sale de cada árbol.

El objeto compartido no sabe dónde está: no tiene x ni y. Si los tuviera, ya no podría servir a dos árboles a la vez. Ese es el precio: el estado extrínseco hay que pasarlo de un lado a otro.

Paso 7 de 12

Compromiso

Compartido significa inmutable

Imagina que alguien cambia la textura de un roble para pintarlo en otoño. Como el objeto es compartido, cambiarían los 10.000 robles a la vez.

Por eso la fábrica lo congela. Con Object.freeze, la escritura no cambia nada, y en modo estricto (los módulos de JavaScript lo son) lanza un TypeError. Si un árbol necesita algo distinto, eso es estado extrínseco y va en el árbol.

Paso 8 de 12

Concepto

No es cualquier caché

Tres ideas equivocadas. Flyweight no es «cualquier caché»: una caché guarda resultados; un flyweight es una parte inmutable que comparten muchos objetos.

No siempre ahorra memoria: con pocos objetos el Map y la indirección cuestan más. Y == no compara valores: solo da true cuando los dos lados salieron de la misma caché.

Paso 9 de 12

Técnica

Dónde te lo cruzas: `Integer.valueOf`

La documentación de Java dice que Integer.valueOf(int) siempre guarda en caché los valores de -128 a 127, y que puede guardar otros. Pedir dos veces 127 devuelve el mismo objeto, así que a == b es true.

Con 128 la caché no está garantizada: c == d puede ser false. Es una pregunta típica de entrevista y un bug real. Para comparar valores, usa equals.

Paso 10 de 12

Técnica

Strings internados e instancing

Java guarda un pool de strings: s.intern() == t.intern() es true exactamente cuando s.equals(t). En Python, sys.intern hace que comparar claves de un diccionario sea comparar punteros.

En los juegos, el GPU instancing de Unity dibuja muchas copias de una misma malla con un mismo material en una sola llamada de dibujo, y cada instancia tiene sus propias propiedades, como el color o la escala. Es la misma separación: malla compartida, posición de cada instancia.

Paso 11 de 12

Compromiso

Cuándo Flyweight no compensa

Si tienes miles de objetos y no millones, o si los datos «compartidos» en realidad cambian en cada objeto, no hay nada que ganar: el Map, la fábrica y el estado que pasas por fuera son complejidad pura.

Y la caché puede crecer sin límite: decide un conjunto fijo de claves o una política para sacar entradas. Hasta Unity avisa de que el instancing puede costar más de lo que ahorra según la plataforma. Antes de aplicarlo, mide la memoria.

Paso 12 de 12

Resumen

Guarda una vez lo que se repite

Cuando necesitas muchísimos objetos parecidos, separa la parte que se repite (intrínseca) de la que cambia (extrínseca). La primera vive una vez, inmutable, y la reparte una fábrica con caché.

Cada uso guarda solo lo suyo y una referencia. Compara con equals, no con ==, y no lo uses sin haber medido.

Aprenderás

  • Separar los datos de un objeto en la parte compartida (intrínseca) y la parte de cada uso (extrínseca).
  • Compartir la parte intrínseca con una fábrica que guarda los objetos en una caché.
  • Explicar por qué un objeto compartido tiene que ser inmutable.
  • Reconocer Flyweight en la caché de `Integer`, en el interning de strings y en el instancing de los motores de juego.
  • Saber cuándo Flyweight no compensa.