Welcome to the first lesson in our Creational Design Patterns course. We are starting with a powerful and widely used pattern: the Singleton Pattern. This pattern helps ensure that a class has only one instance and provides a global point of access to it. Understanding this pattern is a fantastic first step on your journey to mastering creational design patterns.

In Ruby, implementing the Singleton Pattern is quite convenient due to its built-in support. The Singleton module can be included in any class to make it a Singleton. This module provides methods to guarantee that only one instance of the class exists and simplifies global access.

In this lesson, you'll learn how to implement the Singleton Pattern in Ruby. We'll cover the following key points:

1. Including the Singleton Module: We'll explore how to use Ruby's Singleton module to ensure that a class has exactly one instance.
2. Accessing the Singleton Instance: You'll learn how to access this single instance through a global access point provided by the Singleton module.

Here's a sneak peek of the code you'll be working with:

Ruby
Copy to clipboard
1require 'singleton'
2
3class Logger
4  include Singleton
5
6  # Log a message to the console
7  def log(message)
8    puts message
9  end
10end
11
12# Access the Logger instance and log a message
13logger1 = Logger.instance
14logger2 = Logger.instance
15puts logger1.object_id == logger2.object_id # Output: true
16
17logger1.log("Singleton pattern example with Logger.")
18logger2.log("Hey, another message logged!")

In this Ruby snippet, you can see how we ensure that only one Logger instance is created. By including the Singleton module, we automatically get a configured instance method, which acts as the global access point.

Notice, that the Logger.instance method always returns the same object. This behavior is guaranteed by the Singleton Pattern and we can confirm it by comparing the object IDs of the two instances. As expected, they are equal, indicating that both variables point to the same object.

These are the essential parts of the Singleton Pattern:

• Singleton Module: The Singleton module provides all the necessary functionality to create a Singleton class.
• Instance Method: The instance method is used to access the single instance of the class without instantiation.

In addition to the built-in Singleton module, you can manually implement the Singleton Pattern in Ruby. Here's how you can achieve the same behavior without the Singleton module:

Ruby
Copy to clipboard
1class Logger
2  # Class method to access the single instance
3  def self.instance
4    @instance ||= new
5  end
6
7  # Log a message with a count of total logs
8  def log(message)
9    @log_count += 1
10    puts "#{message} (Log count: #{@log_count})"
11  end
12
13  private
14
15  # Constructor initializes log count
16  def initialize
17    @log_count = 0
18  end
19
20  # Restrict instantiation to the class itself
21  private_class_method :new
22end
23
24# Usage example
25Logger.instance.log('First log message.')
26Logger.instance.log('Second log message.')

In this manual implementation:

• The self.instance class method is used to access the singleton instance. It utilizes the @instance variable to store the instance, created only if it doesn't already exist, thanks to Ruby's memoization operator (||=).
• The new method is made private using private_class_method :new to prevent external instantiation of the Logger class.
• The initialize method is defined to set up any necessary instance variables, such as @log_count.

The Singleton Pattern offers several benefits, such as:

• Global Access: Provides a global point of access to a single instance.
• Memory Efficiency: Avoids redundant object creation, saving memory.
• Consistent Behavior: Ensures that all clients use the same instance, maintaining consistency.

However, the Singleton Pattern also has some drawbacks:

• Global State: Can introduce global state, making it harder to manage dependencies.
• Testing Challenges: Testing singletons can be difficult due to their global nature.
• Concurrency Issues: In a multithreaded environment, you should ensure thread safety; however, Ruby's Singleton module handles this by default.
• Lifetime Management: The singleton instance is created when it's first needed and remains until the program ends, which may not be ideal for all scenarios.

The Singleton Pattern is critical for scenarios where exactly one object is needed to manage a specific task, such as logging, configuration settings, or managing database connections. By guaranteeing that only one instance of a class exists, you can avoid redundancy, save memory, and ensure consistent behavior throughout your application.

In Ruby, the Singleton module simplifies the implementation of this pattern, aligning well with Ruby’s design philosophy of simplicity and efficiency. Understanding and implementing the Singleton Pattern in Ruby will provide you with a robust tool for managing resources efficiently. It's a simple yet powerful way to improve your program's design and reliability. Let's dive in and learn how to apply this pattern effectively.

Are you ready? Let’s start coding!