Design Pattern In Golang :
Singleton Pattern
Rihab Sakhri
01
What is the Singleton Pattern?
The Singleton Pattern is a design pattern that
restricts a class to a single instance and provides
a global point of access to that instance. This can
be particularly useful when you want to control
access to shared resources, like a configuration
object or a connection pool.
Rihab Sakhri
Key Characteristics :
1. Single Instance : Only one instance of the class can exist.
2. Global Access Point : The instance can be accessed globally,
usually through a static method.
3. Lazy Initialization : The instance is created only when it is
needed, not when the application starts.
Rihab Sakhri
03
When to Use the Singleton
Pattern:
- When you need exactly one instance of a class to coordinate
actions across the system.
- When the overhead of creating and destroying instances is too
costly.
- When you want to control access to shared resources.
Rihab Sakhri
Implementation in Go :
Here's how you can implement the Singleton Pattern in Go:
Rihab Sakhri
05
Implementation in Go (Continued) :
Rihab Sakhri
Explanation of the Code :
1. Singleton Struct : This is the main struct that holds any
necessary fields. In our example, we have a value field
to demonstrate how we can interact with the singleton
instance.
2. Global Variables :
- instance: This variable holds the single instance of the Singleton
struct.
- mu: A mutex is used to ensure that access to the singleton instance
is thread-safe, preventing race conditions when multiple goroutines
try to access it simultaneously.
3. Singleton Struct : This function checks if the instance is nil. If it is
it creates a new instance of Singleton and initializes it.
- The [Link]() and defer [Link]() ensure that only one
goroutine can create the instance at a time, maintaining the singleton
property.
Rihab Sakhri
07
Explanation of the Code (continued) :
4. SetValue and GetValue Methods : These methods allow you to
interact with the singleton instance. You can set and get the value of
the singleton.
5. Main Function :
- In the main function: we demonstrate how to get the instance of the
singleton, set a value, and retrieve it.
- We also check if both singleton1 and singleton2 are the same
instance, which they should be, confirming the singleton behavior
Rihab Sakhri
Key Advantages of the Singleton
Pattern:
1. Controlled Access : Since there is only one instance, you can
control how it is accessed and modified.
2. Reduced Memory Footprint : It avoids the overhead of
creating multiple instances of a class, especially for
resources that are expensive to create.
3. Global Access Point : Provides a simple way to access
shared resources without passing instances around.
Rihab Sakhri
09
Key Disadvantages of the
Singleton Pattern:
1. Global State : It essentially introduces a global state into your
application, which can make testing and debugging more challenging.
2. Hidden Dependencies : Other parts of the code may rely
on the singleton, leading to hidden dependencies that can
complicate the code structure.
3. Difficulties in Extending : If you want to extend the
functionality of the singleton, it can become tricky because the
pattern enforces a single instance. This can limit flexibility in your
design.
Rihab Sakhri
Use Cases for the Singleton Pattern :
1. Configuration Management : A single configuration object that
holds application settings.
2. Logging : A logger that writes to a file or console,
ensuring all parts of the application use the same logging
instance.
3. Database Connections : Managing a single connection
pool to a database, which can be expensive to create
repeatedly.
Rihab Sakhri
11
Conclusion :
The Singleton Pattern can be a powerful tool in your design
arsenal, but like any design pattern, it should be used
judiciously. It’s great for ensuring that only one instance of a
resource exists, but it’s essential to be aware of the potential
downsides, such as global state and hidden dependencies.
In Golang, implementing the Singleton Pattern is a great way
to get comfortable with struct and concurrency concepts. Just
remember to keep your design clean and maintainable!
Rihab Sakhri
Thank you!
We'll dive deeper into the design pattern and
explore the factory pattern in an upcoming
post so you don’t miss it!
Rihab Sakhri