Styjun

I have a singleton class, which requires a network operation with asynchronous callback to initialize. Any member function of that class should only be called when initialization callback finished.

What I'm not clear with, is how to wait for asynch callback to finish before I return a singleton instance to a caller? Or maybe is there any other way to ensure initialization completes before any function can be called (only initialization should be sequential, all operations after that shouldn't be).

Here's the minimal code:

class DataProvider 

 public static let instance: DataProvider 
 // on first call wait here until callback is done
 // on subsequent calls, no need to wait since already initialized
 return internalInstance
 

 private static let internalInstance = DataProvider()

 private init() 
 initialize()
 

 private func initialize() 
 Something.callAsynch (result, error) in
 // instance becomes ready when this line is executed
 
 

 public func doSomething() 
 // this function should only run after asynch callback was executed
 

This class is called by other classes and potentially other threads like this:

DataProvider.instance.doSomething()

With some help, I found a good solution, that is both reliable and simple. The solution is to use count-down latch. Unfortunately there's no built-in class like that in Swift, but some implementations could be found online (for example: this class from Uber). So this is a solution:

class DataProvider 

 public static let instance: DataProvider 
 // on first call wait here until callback is done
 // on subsequent calls, no need to wait since already initialized
 return internalInstance
 
 private static let internalInstance = DataProvider()

 private let initLatch = CountDownLatch(1)

 private init() 
 initialize()
 

 private func initialize() 
 Something.callAsynch (result, error) in
 // instance becomes ready when this line is executed
 initLatch.countDown()
 
 

 public func doSomething() 
 initLatch.await()
 // this function should only run after asynch callback was executed
 

So what does it do:

• the latch is set to 1 so any caller of doSomething will be suspended until latch is decremented to 0


• latch is only decremented to 0 in one place (init completion callback), hence nobody will proceed before initialization completed


• but after latch is set to 0, calling doSomething will not be delayed

Notes:

• This is a simplified model for problem and solution. In reality there are some other factors that may need to be taken into account, and would require other concurrency tools.


• In my case, the callers are non-interactive, hence I do want them to wait rather than be asynchronous. If callers were interactive, I'd let them deal with asynchronous nature of this class instead.