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
- 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.
← → paso · R repetir · Espacio pausa
Aprenderás
- Separar los datos de un objeto en la parte compartida (intrínseca) y la parte de cada uso (extrínseca). (visto)
- Compartir la parte intrínseca con una fábrica que guarda los objetos en una caché. (visto)
- Explicar por qué un objeto compartido tiene que ser inmutable. (visto)
- Reconocer Flyweight en la caché de `Integer`, en el interning de strings y en el instancing de los motores de juego. (visto)
- Saber cuándo Flyweight no compensa. (visto)