Search for a command to run...
A structural design pattern that optimizes memory usage by sharing common parts of the state among multiple objects
Android Developer With the experience of 9 plus years | Expert in Kotlin, Java, And KMM | Expert Android Jetpack, Coroutine, and MVVM | 30 plus Applications developed | 10 plus on Play stores.
Every positive action, no matter how small, contributes to the greater good of humanity.
No comments yet. Be the first to comment.
What is the Proxy Pattern? The Proxy pattern is a structural design pattern that provides a surrogate or placeholder for another object to control access to it. It allows you to add a layer of indirection to control access, manage complexity, and enh...
The Composite design pattern facilitates the composition of objects into tree structures, enabling the manipulation of these structures as if the
The Bridge design pattern helps break down a big class or a group of closely linked classes into two parts: abstraction and implementation. These part
ProblemImagine you're developing a fitness tracking application that gathers workout data from various fitness devices in XML format and generates detailed performance summaries for users.As you strive to enhance the app's capabilities, you contempla...
The Flyweight pattern is a structural design pattern that aims to minimize memory usage or computational expenses by sharing as much as possible with similar objects. It achieves this by sharing common data between multiple objects instead of duplicating it, thereby reducing memory consumption.
Memory Efficiency: Use the Flyweight pattern when you need to conserve memory by avoiding redundant data in similar objects.
Performance Optimization: Use it when you want to improve performance by reducing the computational overhead associated with creating and managing large numbers of objects.
State Sharing: Use it when multiple objects can share a common state, such as intrinsic properties or immutable data.
Identify Common State: Identify the parts of the object's state that can be shared among multiple instances.
Extract Shared State: Extract the common state into a separate class, referred to as the "flyweight" class.
Create Flyweight Factory: Create a factory class responsible for managing and providing flyweight objects. It ensures that each unique piece of shared state is represented by a single flyweight object.
Use Flyweight Objects: Instantiate flyweight objects through the factory when needed. These objects should reference the shared state rather than maintaining their own copies.
Optional: Unshared State: If necessary, maintain non-shareable state separately in the client objects.
Let's illustrate the Flyweight pattern with an example of a text editor application that stores and displays formatted text. We'll focus on sharing font properties among multiple characters in the text.
kotlinCopy code// Step 1: Identify Common State
data class Font(val name: String, val size: Int, val color: String)
// Step 2: Extract Shared State (Flyweight)
class FontFactory {
private val flyweights: MutableMap<String, Font> = mutableMapOf()
fun getFont(name: String, size: Int, color: String): Font {
val key = "$name-$size-$color"
return flyweights.getOrPut(key) { Font(name, size, color) }
}
}
// Step 3: Create Flyweight Factory
object FlyweightFactory {
val fontFactory = FontFactory()
}
// Step 4: Use Flyweight Objects
class Character(val char: Char, val font: Font) {
fun display() {
println("Character: $char, Font: ${font.name}, Size: ${font.size}, Color: ${font.color}")
}
}
// Step 5: Client Usage
fun main() {
val fontFactory = FlyweightFactory.fontFactory
val font1 = fontFactory.getFont("Arial", 12, "Black")
val font2 = fontFactory.getFont("Arial", 12, "Black")
val font3 = fontFactory.getFont("Times New Roman", 14, "Red")
val char1 = Character('A', font1)
val char2 = Character('B', font2)
val char3 = Character('C', font3)
char1.display()
char2.display()
char3.display()
}
Memory Efficiency: Reduces memory consumption by sharing a common state.
Improved Performance: Reduces object creation overhead, leading to better performance.
Simplified Design: Promotes a cleaner design by separating shared state from unique state.
Complexity: Introduces additional complexity with the need for flyweight factories and coordination between shared and unshared states.
Potential Overhead: Managing shared state and coordinating access to it may introduce overhead, impacting performance in some cases.
Thread Safety: Ensure thread safety when accessing shared state in concurrent environments.
Caching Strategies: Implement efficient caching strategies to minimize the overhead associated with managing flyweight objects.
Monitoring and Optimization: Monitor memory usage and performance to identify opportunities for further optimization and fine-tuning.