En programación informática , el patrón de diseño de software flyweight se refiere a un objeto que minimiza el uso de memoria al compartir algunos de sus datos con otros objetos similares. El patrón flyweight es uno de los veintitrés patrones de diseño GoF conocidos . [1] Estos patrones promueven el diseño de software orientado a objetos flexible, que es más fácil de implementar, cambiar, probar y reutilizar.
En otros contextos, la idea de compartir estructuras de datos se denomina " hash consing" .
El término fue acuñado por primera vez, y la idea fue explorada ampliamente, por Paul Calder y Mark Linton en 1990 [2] para manejar eficientemente la información de glifos en un editor de documentos WYSIWYG . [3] Sin embargo, ya se utilizaban técnicas similares en otros sistemas, ya en 1988. [4]
El patrón flyweight es útil cuando se trabaja con una gran cantidad de objetos que comparten elementos simples repetidos que utilizarían una gran cantidad de memoria si se los incorporara individualmente. Es común mantener datos compartidos en estructuras de datos externas y pasarlos a los objetos temporalmente cuando se los utiliza.
Un ejemplo clásico son las estructuras de datos que se utilizan para representar caracteres en un procesador de textos . De manera sencilla, cada carácter de un documento podría tener un objeto glifo que contenga el contorno de la fuente, las métricas de la fuente y otros datos de formato. Sin embargo, esto utilizaría cientos o miles de bytes de memoria para cada carácter. En cambio, cada carácter puede tener una referencia a un objeto glifo compartido por cada instancia del mismo carácter en el documento. De esta manera, solo es necesario almacenar internamente la posición de cada carácter.
Como resultado, los objetos de peso mosca pueden: [5]
Los clientes pueden reutilizar Flyweightobjetos y pasarlos al estado extrínseco según sea necesario, reduciendo la cantidad de objetos creados físicamente.
El diagrama de clases UML anterior muestra:
Clientclase que utiliza el patrón flyweightFlyweightFactoryclase que crea y comparte FlyweightobjetosFlyweight interfaz , que toma el estado extrínseco y realiza una operaciónFlyweight1clase que implementa Flyweighty almacena el estado intrínsecoEl diagrama de secuencia muestra las siguientes interacciones en tiempo de ejecución :
Clientobjeto llama getFlyweight(key)a FlyweightFactory, que devuelve un Flyweight1objeto.operation(extrinsicState)al Flyweight1objeto devuelto, Clientvuelve a llamar getFlyweight(key)a FlyweightFactory.FlyweightFactoryel objeto ya existente Flyweight1.Existen múltiples formas de implementar el patrón flyweight. Un ejemplo es la mutabilidad: si los objetos que almacenan el estado flyweight extrínseco pueden cambiar.
Los objetos inmutables se comparten fácilmente, pero requieren la creación de nuevos objetos extrínsecos cada vez que se produce un cambio de estado. Por el contrario, los objetos mutables pueden compartir el estado. La mutabilidad permite una mejor reutilización de los objetos mediante el almacenamiento en caché y la reinicialización de objetos antiguos que no se utilizan. El uso compartido suele ser inviable cuando el estado es muy variable.
Otras preocupaciones principales incluyen la recuperación (cómo el cliente final accede al flyweight), el almacenamiento en caché y la simultaneidad .
La interfaz de fábrica para crear o reutilizar objetos flyweight suele ser una fachada para un sistema subyacente complejo. Por ejemplo, la interfaz de fábrica se implementa comúnmente como un singleton para proporcionar acceso global para crear objetos flyweight.
En términos generales, el algoritmo de recuperación comienza con una solicitud de un nuevo objeto a través de la interfaz de fábrica.
La solicitud se envía normalmente a una memoria caché adecuada en función del tipo de objeto que sea. Si la solicitud se cumple con un objeto de la memoria caché, es posible que se reinicie y se devuelva. De lo contrario, se crea una instancia de un nuevo objeto. Si el objeto se divide en varios subcomponentes extrínsecos, se unirán antes de que se devuelva el objeto.
Hay dos formas de almacenar en caché objetos flyweight: cachés mantenidos y no mantenidos.
Los objetos con un estado muy variable se pueden almacenar en caché con una estructura FIFO . Esta estructura mantiene los objetos no utilizados en la caché, sin necesidad de realizar búsquedas en ella.
Por el contrario, las cachés sin mantenimiento tienen menos sobrecarga inicial: los objetos para las cachés se inicializan en masa en el momento de la compilación o el inicio. Una vez que los objetos llenan la caché, el algoritmo de recuperación de objetos puede tener más sobrecarga asociada que las operaciones de inserción/extracción de una caché con mantenimiento.
Al recuperar objetos extrínsecos con estado inmutable, simplemente se debe buscar en la memoria caché un objeto con el estado deseado. Si no se encuentra dicho objeto, se debe inicializar uno con ese estado. Al recuperar objetos extrínsecos con estado mutable, se debe buscar en la memoria caché un objeto no utilizado para reinicializarlo si no se encuentra ningún objeto utilizado. Si no hay ningún objeto no utilizado disponible, se debe crear una instancia de un nuevo objeto y agregarlo a la memoria caché.
Se pueden utilizar cachés independientes para cada subclase única de objeto extrínseco. Se pueden optimizar varios cachés por separado, asociando un algoritmo de búsqueda único con cada caché. Este sistema de almacenamiento en caché de objetos se puede encapsular con el patrón de cadena de responsabilidad , que promueve un acoplamiento flexible entre los componentes.
Se debe tener en cuenta una consideración especial cuando se crean objetos flyweight en varios subprocesos. Si la lista de valores es finita y se conoce de antemano, los flyweights se pueden instanciar con anticipación y recuperar de un contenedor en varios subprocesos sin contención. Si los flyweights se instancian en varios subprocesos, hay dos opciones:
Para permitir el intercambio seguro entre clientes y subprocesos, los objetos flyweight se pueden convertir en objetos de valor inmutables , donde dos instancias se consideran iguales si sus valores son iguales.
Este ejemplo de C# 9 utiliza registros [7] para crear un objeto de valor que representa sabores de café:
registro público CoffeeFlavours ( sabor de cadena ); En este ejemplo, cada instancia de la MyObjectclase utiliza una Pointerclase para proporcionar datos.
// Define un objeto Flyweight que se repite. public class Flyweight { public string Name { get ; set ; } public string Location { get ; set ; } public string Website { get ; set ; } public byte [] Logo { get ; set ; } } clase pública estática Pointer { pública estática de solo lectura Flyweight Company = new Flyweight { "Abc" , "XYZ" , "www.example.com" }; } clase pública MyObject { cadena pública Nombre { obtener ; establecer ; } cadena pública Empresa = > Puntero.Empresa.Nombre ; } La biblioteca de plantillas estándar de C++ ofrece varios contenedores que permiten asignar objetos únicos a una clave. El uso de contenedores ayuda a reducir aún más el uso de memoria al eliminar la necesidad de crear objetos temporales.
#include <iostream> #include <mapa> #include <cadena> // Las instancias de Tenant serán la clase Flyweights Tenant { public : Tenant ( const std :: string & name = "" ) : m_name ( name ) {} std :: string nombre () const { return m_nombre ; } privado : std :: string m_nombre ; }; // El registro actúa como una fábrica y un caché para los objetos flyweight de Tenant class Registry { public : Registry () : inquilinos () {} Inquilino & findByName ( const std :: string & nombre ) { if ( ! inquilinos.contiene ( nombre )) { inquilinos [ nombre ] = Inquilino { nombre } ; } return inquilinos [ nombre ]; } private : std :: map < std :: string , Inquilino > inquilinos ; } ; // El apartamento asigna un inquilino único a su número de habitación. class Apartment { public : Apartment () : m_occupants (), m_registry () {} void addOccupant ( const std :: string & nombre , int habitación ) { m_occupants [ habitación ] = & m_registry.findByName ( nombre ) ; } void inquilinos () { for ( const auto & i : m_ocupantes ) { const int & habitación = i . primero ; const auto & inquilino = i . segundo ; std :: cout << inquilino -> nombre () << " ocupa habitación " << habitación << std :: endl ; } } privado : std :: map < int , Inquilino *> m_ocupantes ; Registro m_registry ; }; int main () { Apartamento apartamento ; departamento . addOccupant ( "David" , 1 ); departamento . addOccupant ( "Sara" , 3 ); departamento . agregarOcupante ( "George" , 2 ); departamento . agregarOcupante ( "Lisa" , 12 ); departamento . agregarOcupante ( "Michael" , 10 ); departamento . inquilinos (); devuelve 0 ; } <?phpclase SaborCafé { matriz estática privada $CACHE = []; función privada __construct ( cadena privada $nombre ) {} función pública estática interna ( cadena $nombre ) : self { self :: $CACHE [ $nombre ] ??= new self ( $nombre ); return self :: $CACHE [ $nombre ]; } función pública estática flavorsInCache () : int { return count ( self :: $CACHE ); } función pública __toString () : cadena { return $this -> nombre ; }}clase Orden { función privada __construct ( private CoffeeFlavour $sabor , private int $tableNumber ) {} función pública estática create ( string $nombreSabor , int $numeroTabla ) : self { $sabor = SaborCafé :: intern ( $nombreSabor ); return new self ( $sabor , $numeroTabla ); } función pública __toString () : cadena { devolver "Sirviendo { $this -> flavor } a la mesa { $this -> tableNumber } " ; } }clase Cafetería { matriz privada $orders = []; función pública tomarOrden ( string $sabor , int $numeroDeTabla ) { $this -> pedidos [] = Pedido :: crear ( $sabor , $numeroDeTabla ); } función pública servicio () { imprimir ( implosionar ( PHP_EOL , $ this -> pedidos ) .PHP_EOL ); } } $tienda = new CoffeeShop (); $tienda -> takeOrder ( "Capuchino" , 2 ); $tienda -> takeOrder ( "Frappe" , 1 ); $tienda -> takeOrder ( "Espresso" , 1 ); $tienda -> takeOrder ( "Frappe" , 897 ); $tienda -> takeOrder ( "Capuchino" , 97 ); $ tienda - > takeOrder ( "Frappe" , 3 ); $tienda -> takeOrder ( "Espresso" , 3 ); $tienda -> takeOrder ( "Capuchino" , 3 ); $tienda -> takeOrder ( "Espresso" , 96 ); $tienda -> takeOrder ( "Frappe" , 552 ); $tienda -> takeOrder ( "Capuchino" , 121 ); $tienda -> takeOrder ( "Espresso" , 121 ); $tienda -> servicio (); print ( "Objetos CoffeeFlavor en caché: " . CoffeeFlavour :: saboresInCache () . PHP_EOL );{{cite book}}: CS1 maint: multiple names: authors list (link)