From my short experience with iOS8 Swift there are three approaches to implement the Singleton pattern that support lazy initialisation and thread safety.

Download the Source Files for example

These approaches might change or become redundant as the language matures.

Global constant


1
2
3
4
5
6
7
private let _SingletonSharedInstance = Singleton()

class Singleton  {
    class var sharedInstance : Singleton {
        return _SingletonSharedInstance
    }
}

We use a global constant because class constants are not yet supported.

This approach supports lazy initialization because Swift lazily initializes global constants (and variables), and is thread safe by virtue of let.

Nested struct


1
2
3
4
5
6
7
8
class Singleton {
    class var sharedInstance : Singleton {
        struct Static {
            static let instance : Singleton = Singleton()
        }
        return Static.instance
    }
}

Unlike classes, structs do support static constants. By using a nested struct we can leverage its static constant as a class constant.

The nested struct is the approach I recommend until class constants are supported.

dispatch_once

The traditional Objective-C approach ported to Swift. I’m fairly certain there’s no advantage over the nested struct approach but I’m putting it here anyway as I find the differences in syntax interesting.


1
2
3
4
5
6
7
8
9
10
11
12
class Singleton {
    class var sharedInstance : Singleton {
        struct Static {
            static var onceToken : dispatch_once_t = 0
            static var instance : Singleton? = nil
        }
        dispatch_once(&Static.onceToken) {
            Static.instance = Singleton()
        }
        return Static.instance!
    }
}

Download the Source Files for example

Enjoyed this post?

Subscribe to our RSS Feed or Follow us on twitter to keep up to date with the latest from iOS-Blog. Remember, Sharing is caring so please click one of the following options:

Tags: , , ,