SOFTWARE ENGINEERING JOURNEY
Flyweight Pattern: Improve The Performance of Software Systems by Reducing The Amount of Memory Used
Top Design Patterns Software Engineer Should Know
Overview
The Flyweight pattern is a design pattern that is used in software engineering to optimize the use of memory resources. It is a structural pattern that focuses on the creation of lightweight objects that can be shared between different instances. This pattern is particularly useful in situations where there are a large number of objects that have similar characteristics and where memory is limited.
The Flyweight pattern is based on the concept of sharing objects to reduce memory usage. In this pattern, a single instance of a class is created and shared among multiple objects. The shared instance is known as the flyweight object, and it contains the intrinsic state of the objects. The intrinsic state is the data that is common to all objects and does not change over time. The extrinsic state is the data that varies from one object to another, and it is stored outside the flyweight object.
Advantages
- Reduced memory usage: By sharing objects, less memory is required to store the data, which can be particularly important in situations where memory is limited, such as in embedded systems or mobile devices.
- Improved performance: By reducing the amount of memory used, the system can run faster and more efficiently, which can be particularly important in real-time systems, such as games or simulations.
- Scalability: The Flyweight pattern can be used to manage large sets of objects, which can help to improve the scalability of the system.
- Reusability: Flyweight objects can be reused in different parts of the system, which can help to reduce code duplication and improve maintainability.
- Flexibility: The Flyweight pattern can be implemented in different ways, which can provide flexibility in how it is used.
Disadvantages
- Complexity: The use of shared objects can make the code more complex and difficult to understand and maintain.
- Overhead: The use of a factory or cache to manage flyweight objects can add some overhead to the system, which can affect performance.
- Limitations: The Flyweight pattern is most useful when dealing with large sets of objects with common characteristics. It may not be appropriate for situations where the objects have unique characteristics.
- Thread-safety: Sharing objects between multiple threads can introduce concurrency issues and requires careful synchronization.
- Intrinsic state limitations: The intrinsic state of a flyweight object cannot be modified once it is created, which limits the flexibility of the pattern.
Real-world software projects be applied
#1 Games
The Flyweight pattern can be used in games to manage the creation of objects such as terrain, trees, and other scenery elements that are repeated throughout the game world. By using a flyweight object to represent these elements, memory usage can be reduced, and performance can be improved.
Example:
Factory Classes:
Execute Classes:
In this example, the GameObjectFactory class is used to manage the creation of GameObject flyweight objects. The factory maintains a map of existing flyweight objects, keyed by name. When a client requests a flyweight object using the getGameObject method, the factory checks if an object with the requested name already exists. If it does, the existing object is returned. Otherwise, a new object is created and added to the map before being returned to the client.
The GameObject class represents a game object, with a name and color. The draw method is used to draw the object on the screen at a given position.
In the Game class, we create two GameObject objects using the GameObjectFactory, with the same name and color. We then draw the objects at different positions and check that they are the same object using the == operator. Since the GameObject objects are flyweights, they are the same object in memory, and the check returns true.
#2 Web applications
The Flyweight pattern can be used in web applications to manage the creation of objects such as images, icons, and other graphical elements that are used repeatedly throughout the application. By using a flyweight object to represent these elements, network bandwidth can be conserved, and the application can be more responsive.
Example:
Factory Classes:
Execute Classes:
In this example, the ImageFactory class is used to manage the creation of Image flyweight objects. The factory maintains a map of existing flyweight objects, keyed by file name. When a client requests an image object using the getImage method, the factory checks if an object with the requested file name already exists. If it does, the existing object is returned. Otherwise, a new object is created and added to the map before being returned to the client.
The Image class represents an image object, with a file name. The getFileName method is used to get the file name of the image.
In the WebPage class, we create an array of Image objects using the ImageFactory, with file names for a logo, a background, and a button. We then render the images on the web page using the render method, which generates HTML <img> tags for each image.
In the WebApp class, we create a WebPage object and call its render method to display the images on the web page.
#3 Text processing
The Flyweight pattern can be used in text processing applications to manage the creation of objects such as font characters or symbols that are used repeatedly throughout a document. By using a flyweight object to represent these elements, memory usage can be reduced, and performance can be improved.
Example:
Factory Classes:
Execute Classes:
In this example, the FontFactory class is used to manage the creation of Font flyweight objects. The factory maintains a map of existing flyweight objects, keyed by font name and size. When a client requests a font object using the getFont method, the factory checks if an object with the requested name and size already exists. If it does, the existing object is returned. Otherwise, a new object is created and added to the map before being returned to the client.
The Font class represents a font object, with a name and size. The getName and getSize methods are used to get the name and size of the font.
In the TextDocument class, we create an array of Font objects using the FontFactory, with names and sizes for Arial 12, Times New Roman 14, and Arial 12. We then load an array of text strings to display. In the display method, we iterate over the text and fonts, and generate HTML <span> tags for each text string with the corresponding font style.
In the TextProcessor class, we create a TextDocument object and call its display method to show the text with the corresponding fonts.
#4 Databases
The Flyweight pattern can be used in databases to manage the creation of objects such as database connections or result sets that are used repeatedly throughout the application. By using a flyweight object to represent these elements, memory usage can be reduced, and performance can be improved.
Example:
Factory Classes:
Execute Classes:
In this example, the DatabaseConnectionFactory class is used to manage the creation of Connection flyweight objects for a database. The factory maintains a map of existing flyweight objects, keyed by the database URL and username. When a client requests a connection object using the getConnection method, the factory checks if an object with the requested URL and username already exists. If it does, the existing object is returned. Otherwise, a new object is created and added to the map before being returned to the client.
The DatabaseAccess class represents a client that needs to access the database. In the queryDatabase method, we request a connection object from the DatabaseConnectionFactory using the URL, username, and password. We can then perform database queries using the connection before closing it.
In the DatabaseApplication class, we create a DatabaseAccess object and call its queryDatabase method to access the database.
#5 Network protocols
The Flyweight pattern can be used in network protocols to manage the creation of objects such as message headers or protocol states that are used repeatedly throughout the protocol. By using a flyweight object to represent these elements, memory usage can be reduced, and the protocol can be more efficient.
Example:
Factory Classes:
Execute Classes:
In this example, the NetworkProtocolFactory class is used to manage the creation of NetworkProtocol flyweight objects for different network protocols. The factory maintains a map of existing flyweight objects, keyed by the address, port, and type of protocol. When a client requests a protocol object using the getProtocol method, the factory checks if an object with the requested parameters already exists. If it does, the existing object is returned. Otherwise, a new object is created and added to the map before being returned to the client.
The NetworkProtocol interface defines the common methods that all network protocol objects must implement, including connect and sendData.
The TcpProtocol and UdpProtocol classes represent concrete network protocol objects that implement the NetworkProtocol interface. The TcpProtocol class uses a Socket object to establish a TCP connection to a remote host, while the UdpProtocol class sends data using the UDP protocol.
In the NetworkApplication class, we create NetworkProtocol objects for both TCP and UDP protocols using the factory. We can then use these objects to connect to remote hosts and send data using the appropriate protocol.
Summary
In conclusion, the Flyweight pattern is a useful design pattern that can be used to optimize the use of memory resources in software systems. By sharing objects, less memory is required to store the data, which can improve the performance of the system. However, it is important to carefully consider the requirements of the system before deciding to use the Flyweight pattern, as it can make the code more complex and may not be appropriate in all situations.
In order to discover more about the design patterns please refer to the following links:
