Singleton with parameter in Kotlin

Question

I am trying to convert an Android app from Java to Kotlin. There are a few singletons in the app. I used a companion object for the singletons without constructor parameters. There is another singleton that takes a constructor parameter.

Java code:

public class TasksLocalDataSource implements TasksDataSource {      private static TasksLocalDataSource INSTANCE;      private TasksDbHelper mDbHelper;      // Prevent direct instantiation.     private TasksLocalDataSource(@NonNull Context context) {         checkNotNull(context);         mDbHelper = new TasksDbHelper(context);     }      public static TasksLocalDataSource getInstance(@NonNull Context context) {         if (INSTANCE == null) {             INSTANCE = new TasksLocalDataSource(context);         }         return INSTANCE;     } } 

My solution in kotlin:

class TasksLocalDataSource private constructor(context: Context) : TasksDataSource {      private val mDbHelper: TasksDbHelper      init {         checkNotNull(context)         mDbHelper = TasksDbHelper(context)     }      companion object {         lateinit var INSTANCE: TasksLocalDataSource         private val initialized = AtomicBoolean()          fun getInstance(context: Context) : TasksLocalDataSource {             if(initialized.getAndSet(true)) {                 INSTANCE = TasksLocalDataSource(context)             }             return INSTANCE         }     } } 

Am I missing anything? Thread safety? Laziness ?

There were a few similar questions but I don't like the answers :)

Answer 1

Here's a neat alternative from Google's architecture components sample code, which uses the also function:

class UsersDatabase : RoomDatabase() {      companion object {          @Volatile private var INSTANCE: UsersDatabase? = null          fun getInstance(context: Context): UsersDatabase =             INSTANCE ?: synchronized(this) {                 INSTANCE ?: buildDatabase(context).also { INSTANCE = it }             }          private fun buildDatabase(context: Context) =             Room.databaseBuilder(context.applicationContext,                     UsersDatabase::class.java, "Sample.db")                     .build()     } } 

Answer 2

• Thread-Safe Solution # Write Once; Use Many;

It's a good solution to create a class implementing the logic of singleton which also holds the singleton instance, like the following.

It instantiates the instance using Double-Check Locking in a synchronized block to eliminate possibility of race condition in multi-threaded environments.

SingletonHolder.kt

open class SingletonHolder<out T, in A>(private val constructor: (A) -> T) {      @Volatile     private var instance: T? = null      fun getInstance(arg: A): T =         instance ?: synchronized(this) {             instance ?: constructor(arg).also { instance = it }         } } 

---

• Usage

Now in each class that you want to be singleton, write a companion object extending the above class. SingletonHolder is a generic class that accepts type of target class and its requiring parameter as generic params. It also needs a reference to the constructor of target class which is used for instantiating an instance:

class MyManager private constructor(context: Context) {      fun doSomething() {         ...     }      companion object : SingletonHolder<MyManager, Context>(::MyManager) } 

Finally:

MyManager.getInstance(context).doSomething()