Use Object for Singleton Patterns in Kotlin

Yatin BatraApril 15th, 2025Last Updated: April 15th, 2025

0 91 4 minutes read

The Singleton Design Pattern ensures that a class has only one instance and provides a global point of access to that instance. In Java, implementing a Singleton requires several steps, including managing thread safety. However, Kotlin simplifies this with the object keyword. Let us delve into understanding how Kotlin uses Object for Singleton patterns to ensure a single instance throughout the application lifecycle.

1. Introduction

1.1 What is Singleton in Java?

In Java, a Singleton is implemented using a private constructor and a static method to ensure that only one instance of the class is created.

1.2 What is Singleton in Kotlin?

Kotlin provides a much simpler way to create a Singleton using the object keyword. When we declare an object, Kotlin automatically ensures that only one instance exists, and it offers several advantages:

No Synchronization Required: In Java, making a Singleton thread-safe requires additional logic (e.g., synchronized blocks, double-checked locking). Kotlin’s object is inherently thread-safe, ensuring that multiple threads do not create multiple instances.
More Readable and Maintainable: Java’s Singleton implementation can become verbose and complex with explicit instance checks and synchronization mechanisms. Kotlin’s object provides a clear, declarative way to define a Singleton, making the codebase easier to read and maintain.
Avoids Lazy Loading Overhead: In Java, Singletons often use lazy initialization to defer object creation until needed. However, lazy loading introduces extra overhead (e.g., synchronization for thread safety). Kotlin’s object initializes immediately on first access, ensuring faster execution.
Serialization & Reflection Handling: Java Singletons require special handling for serialization to prevent new instances from being created during deserialization. Kotlin’s object natively maintains Singleton behavior across serialization and reflection, reducing potential issues.
Better Support for Functional and Object-Oriented Programming: Since Kotlin supports both functional and object-oriented paradigms, the object keyword allows defining Singleton objects, companion objects, and anonymous objects, offering greater flexibility compared to Java’s class-based Singleton.
Ideal for Dependency Injection (DI): Frameworks like Dagger (Java) and Koin (Kotlin) require careful instance management for Singletons. Kotlin’s object integrates seamlessly into DI frameworks, simplifying dependency injection without additional configuration.

1.2.1 Importance of Using Singleton in Larger Applications

Singletons play an important role in larger applications by ensuring that only one instance of a class exists and is globally accessible. This pattern is widely used for managing shared resources, improving efficiency, and preventing redundant object creation. Below are some key reasons why Singletons are important in large-scale applications:

Object in Kotlin: In Kotlin, the object keyword is used to create a Singleton class automatically.
Single Instance: The object ensures that only one instance of the class exists throughout the application.
Initialization: When the object is first accessed, it is initialized immediately.
No Constructor: Unlike regular classes, object does not require a constructor.
Thread Safety: The Singleton object is thread-safe by default in Kotlin.
Global Access: The instance of the object can be accessed globally without explicit instantiation.
Use Cases: Commonly used for logging, database connections, network clients, caching, and configuration management.
Example: A Singleton Database Manager, API Client, or Configuration Manager can be implemented using object.

2. Code Example

Imagine a scenario where an application requires a database connection manager that should have only one instance throughout the application’s lifecycle. Using the Singleton pattern, we ensure that only one database connection instance is created, improving efficiency and preventing redundant connections.

import java.sql.Connection
import java.sql.DriverManager
 
object DatabaseManager {
    private var connection: Connection? = null
 
    init {
        try {
            // Simulate database connection setup
            val url = "jdbc:mysql://localhost:3306/mydb"
            val user = "root"
            val password = "password"
            connection = DriverManager.getConnection(url, user, password)
            println("Database connected successfully!")
        } catch (e: Exception) {
            throw RuntimeException("Error connecting to the database!", e)
        }
    }
 
    fun getConnection(): Connection? {
        return connection
    }
}
 
fun main() {
    val db1 = DatabaseManager
    val db2 = DatabaseManager
 
    // Both db1 and db2 should refer to the same instance
    println(db1 === db2) // Output: true
}

2.1 Code Explanation

The given Kotlin program demonstrates the Singleton pattern using the object keyword to create a database connection manager. The DatabaseManager object ensures that only one instance of the database connection exists throughout the application’s lifecycle. It contains a nullable variable connection of type Connection?, which is initialized inside the init block. When the object is first accessed, the init block is executed, establishing a connection to a MySQL database using DriverManager.getConnection() with predefined URL, username, and password. If the connection is successful, a success message is printed; otherwise, an exception is caught, and a RuntimeException is thrown. The getConnection() function provides access to the existing connection instance. In the main function, two references, db1 and db2, are assigned to DatabaseManager. Since DatabaseManager is a Singleton, both references point to the same instance, and println(db1 === db2) confirms this by printing true. This implementation ensures efficient resource management by preventing multiple database connections, making the application more robust and performant.

2.2 Code Output

The code when executed gives the following output:

Database connected successfully!
true

3. Alternative Singleton Implementations

While Kotlin’s object is the most common and recommended way, there are other approaches depending on the use case. Below are the different ways to implement Singletons in Kotlin:

Approach Code Snippet Thread-Safe? Lazy Initialization? Best Use Case

Using lazy {} (Lazy Initialization)

class DatabaseManager private constructor() {
    companion object {
        val instance: DatabaseManager by lazy { DatabaseManager() }
    }
}
 
fun main() {
    val db1 = DatabaseManager.instance
    val db2 = DatabaseManager.instance
    println(db1 === db2) // true
}

Yes

Expensive Object Creation

Using Companion Object

class Logger {
    companion object {
        fun log(message: String) {
            println("Log: $message")
        }
    }
}
 
fun main() {
    Logger.log("This is a log message!")
}

Yes

Utility Functions (Static-like Behavior)

Using Sealed Class

sealed class Config {
    object Debug : Config()
 
    object Release : Config()
}
 
fun main() {
    val env1 = Config.Debug
    val env2 = Config.Debug
    println(env1 === env2) // true
}

Yes

Multiple Singleton Variants

Using Enum Class (Safe Singleton)

enum class AppConfig {
    INSTANCE;
 
    fun getConfiguration() {
        println("Fetching Configuration...")
    }
}
 
fun main() {
    AppConfig.INSTANCE.getConfiguration()
}

Yes

Reflection & Serialization Safe Singleton

Using Dependency Injection (Koin Example)

val appModule = module { single { DatabaseManager() } }
 
class DatabaseManager
 
fun main() {
    val koinApp = startKoin { modules(appModule) }
    val db1: DatabaseManager = koinApp.koin.get()
    val db2: DatabaseManager = koinApp.koin.get()
    println(db1 === db2) // true
}

Yes

Singleton with Dependency Injection

4. Conclusion

Implementing a Singleton in Java requires explicit handling of instance creation, while Kotlin makes it effortless with the object keyword. This not only simplifies code but also ensures thread safety without extra implementation effort.

Use Object for Singleton Patterns in Kotlin

1. Introduction

1.1 What is Singleton in Java?

1.2 What is Singleton in Kotlin?

1.2.1 Importance of Using Singleton in Larger Applications

2. Code Example

2.1 Code Explanation

2.2 Code Output

3. Alternative Singleton Implementations

4. Conclusion

Thank you!

Yatin Batra

Thank you!

1. Introduction

1.1 What is Singleton in Java?

1.2 What is Singleton in Kotlin?

1.2.1 Importance of Using Singleton in Larger Applications

2. Code Example

2.1 Code Explanation

2.2 Code Output

3. Alternative Singleton Implementations

4. Conclusion

Thank you!

Related Articles

Thank you!