By David Berry


2014-06-03 20:41:12 8 Comments

I'm trying to work out an appropriate singleton model for usage in Swift. So far, I've been able to get a non-thread safe model working as:

class var sharedInstance:TPScopeManager {
    get {
        struct Static {
            static var instance : TPScopeManager? = nil
        }

        if !Static.instance {
            Static.instance = TPScopeManager()
        }

        return Static.instance!
    }
}

Wrapping the singleton instance in the Static struct should allow a single instance that doesn't collide with singleton instances without complex naming schemings, and it should make things fairly private. Obviously though, this model isn't thread safe, so I tried to add dispatch_once to the whole thing:

class var sharedInstance:TPScopeManager {
    get {
        struct Static {
            static var instance : TPScopeManager? = nil
            static var token : dispatch_once_t = 0
        }

        dispatch_once(Static.token) { Static.instance = TPScopeManager() }

        return Static.instance!
    }
}

But I get a compiler error on the dispatch_once line:

Cannot convert the expression's type 'Void' to type '()'

I've tried several different variants of the syntax, but they all seem to have the same results:

dispatch_once(Static.token, { Static.instance = TPScopeManager() })

What is the proper usage of dispatch_once using Swift? I initially thought the problem was with the block due to the () in the error message, but the more I look at it, the more I think it may be a matter of getting the dispatch_once_t correctly defined.

30 comments

@Vicky Prajapati 2019-04-26 06:26:39

In swift, you can create a singleton class following way:

class AppSingleton: NSObject {

    //Shared instance of class
    static let sharedInstance = AppSingleton()

    override init() {
        super.init()
    }
}

@David Berry 2019-04-26 19:30:13

Thanks for the answer, but this really doesn't add anything to the previous answers that are several years old.

@applefreak 2018-10-17 16:45:24

The only right approach is below

final class Singleton {
    static let sharedInstance: Singleton = {
        let instance = Singleton()
        // setup code if anything
        return instance
    }()

    private init() {}
}

To Access

let signleton = Singleton.sharedInstance

Reasons:

  • static type property is guaranteed to be lazily initialized only once, even when accessed across multiple threads simultaneously, so no need of using dispatch_once
  • Privatising the init method so instance can't be created by other classes.
  • final class as you do not want other classes to inherit Singleton class

@abhimuralidharan 2019-03-19 05:55:59

Why did you use the closure initialization while you can directly use static let sharedInstance = Singleton()

@applefreak 2019-03-19 20:47:32

if you do not want to do any additional setup then what you saying is right.

@Prashant Bhayani 2018-09-19 07:59:23

use a static variable and private initializer to create a singleton class.

class MySingletonClass {

    static let sharedSingleton = MySingletonClass()

    private init() {}
}

@Martin R 2018-09-19 08:10:34

@Tim 2018-01-03 07:19:26

Swift to realize singleton in the past, is nothing more than the three ways: global variables, internal variables and dispatch_once ways.

Here are two good singleton.(note: no matter what kind of writing will must pay attention to the init () method of privatisation.Because in Swift, all the object's constructor default is public, needs to be rewritten init can be turned into private, prevent other objects of this class '()' by default initialization method to create the object.)

Method 1:

class AppManager {
    private static let _sharedInstance = AppManager()

    class func getSharedInstance() -> AppManager {
       return _sharedInstance
    }

    private init() {} // Privatizing the init method
}

// How to use?
AppManager.getSharedInstance()

Method 2:

class AppManager {
    static let sharedInstance = AppManager()

    private init() {} // Privatizing the init method
}

// How to use?
AppManager.sharedInstance

@Gonzalo Durañona 2017-10-21 01:44:08

I tend to use the following syntax as the most complete:

public final class Singleton {    
    private class func sharedInstance() -> Singleton {
        struct Static {
            //Singleton instance.
            static let sharedInstance = Singleton()
        }
        return Static.sharedInstance
    }

    private init() { }

    class var instance: Singleton {
        return sharedInstance()
    }
}

This works from Swift 1.2 up to 4, and offers several virtues:

  1. Reminds the user not to subclass implementation
  2. Prevents creation of additional instances
  3. Ensures lazy creation and unique instantiation
  4. Shortens syntax (avoids ()) by allowing to access instance as Singleton.instance

@Abhishek Biswas 2017-10-12 12:32:41

This is the simplest one with thread safe capabilities. No other thread can access the same singleton object even if they want. Swift 3/4

struct DataService {

    private static var _instance : DataService?

    private init() {}   //cannot initialise from outer class

    public static var instance : DataService {
        get {
            if _instance == nil {
                DispatchQueue.global().sync(flags: .barrier) {
                    if _instance == nil {
                        _instance = DataService()
                    }
                }
            }
            return _instance!
        }
    }
}

@Martin R 2017-10-12 13:06:50

What is the advantage over a static type property (which is guaranteed to be lazily initialized only once, even when accessed across multiple threads simultaneously) ?

@Adam Smaka 2016-09-09 12:51:39

Swift 4+

protocol Singleton: class {
    static var sharedInstance: Self { get }
}

final class Kraken: Singleton {
    static let sharedInstance = Kraken()
    private init() {}
}

@Raheel Sadiq 2016-09-25 10:11:04

this needs final class, can you explain more the difference, coz I have issue with the other solution of singleton with struct

@NSRover 2016-12-13 16:48:45

should that be private override init() {}

@CodeCracker 2016-04-23 17:22:13

The best approach in Swift above 1.2 is a one-line singleton, as -

class Shared: NSObject {

    static let sharedInstance = Shared()

    private override init() { }
}

To know more detail about this approach you can visit this link.

@Martin R 2016-04-23 18:12:24

Why a NSObject subclass?. Apart from that, this seems to be essentially the same as stackoverflow.com/a/28436202/1187415.

@RicardoDuarte 2016-02-04 00:00:41

I just came across with this, but I required my singleton to allow inheritance, and none of these solutions actually allowed it.

So I came up with this:

public class Singleton {
  private static var sharedInstanceVar = Singleton()

  public class func sharedInstance()->Singleton {
    return sharedInstanceVar
  }
}


public class SubSingleton: Singleton {

  private static var sharedInstanceToken:dispatch_once_t = 0

  public class override func sharedInstance()->SubSingleton {
    dispatch_once(&sharedInstanceToken){
      sharedInstanceVar = SubSingleton()
    }
    return sharedInstanceVar as! SubSingleton
  }
}
  • This way when doing Singleton.sharedInstance() first it will return the instance of Singleton
  • When doing SubSingleton.sharedInstance() first it will return the instance of SubSingleton created.
  • If the above is done, then SubSingleton.sharedInstance() is Singleton is true and the same instance is used.

The issue with this first dirty approach is that I cannot guarantee that subclasses would implement the dispatch_once_t and make sure that sharedInstanceVar is only modified once per class...

I will try to refine this further, but it would be interesting to see if anyone has strong feelings against this (besides the fact that it is verbose and requires to manually update it).

@Ryan 2015-01-13 03:36:32

Swift singletons are exposed in the Cocoa frameworks as class functions, e.g. NSFileManager.defaultManager(), NSNotificationCenter.defaultCenter(), so I feel it makes more sense as a class function to mirror this behaviour, rather than a class variable as some other solutions use, e.g.

class MyClass {

    private static let _sharedInstance = MyClass()

    class func sharedInstance() -> MyClass {
        return _sharedInstance
    }
}

Retrieve the singleton via MyClass.sharedInstance().

@x4h1d 2015-10-14 05:39:05

upvoted for the comment of LearnCocos2D :) , also for the style.

@malhal 2015-12-01 05:09:32

the global variable should be changed to a class variable via a static inside the class.

@Ryan 2015-12-02 03:56:19

@malhal when a variable is marked private but outside a class, it's not global - but scoped only to the file it is in. A static inside the class would work pretty much the same, but i've updated the answer to use the static as you suggested, as it better groups the variable to the class if you happen to use multiple classes within the file.

@Rob 2016-09-22 01:10:27

"Swift Singletons are exposed in the cocoa frameworks as class functions" ... Not in Swift 3. They're now usually static properties.

@Essa A. Haddad 2014-06-07 03:50:54

After seeing David's implementation, it seems like there's no need to have a singleton class function instanceMethod since let is doing pretty much the same thing as a sharedInstance class method. All you need to do is declare it as a global constant and that would be it.

let gScopeManagerSharedInstance = ScopeManager()

class ScopeManager {
 // No need for a class method to return the shared instance. Use the gScopeManagerSharedInstance directly. 
}

@David Berry 2014-06-07 04:18:44

As I say in my comments, the only reason to do it is that at some point in the future you can move/hide the global variable and get more singleton-like behavior. At that point, if everything is using a consistent pattern, you can just change the singleton classes themselves without having to change the usage.

@Kingiol 2014-06-06 08:01:55

Use:

class UtilSingleton: NSObject {

    var iVal: Int = 0

    class var shareInstance: UtilSingleton {
        get {
            struct Static {
                static var instance: UtilSingleton? = nil
                static var token: dispatch_once_t = 0
            }
            dispatch_once(&Static.token, {
                Static.instance = UtilSingleton()
            })
            return Static.instance!
        }
    }
}

How to use:

UtilSingleton.shareInstance.iVal++
println("singleton new iVal = \(UtilSingleton.shareInstance.iVal)")

@David Berry 2014-06-06 15:14:06

This is exactly the same as one of the answers I went through on the way to the current answer. Since global variables are initialized both lazy and thread-safe, there's no reason for the additional complexity.

@hpique 2014-06-10 05:37:34

@David Other than not having a global variable. :)

@David Berry 2014-06-10 14:47:37

@hpique no, exactly like one of my earlier attempts. Look at the edit history.

@user2485100 2014-06-05 02:29:51

Looking at Apple's sample code I came across this pattern. I'm not sure how Swift deals with statics, but this would be thread safe in C#. I include both the property and method for Objective-C interop.

struct StaticRank {
    static let shared = RankMapping()
}

class func sharedInstance() -> RankMapping {
    return StaticRank.shared
}

class var shared:RankMapping {
    return StaticRank.shared
}

@Eonil 2014-06-05 04:18:23

I am pretty sure that just using this default static syntax will do the all annoying jobs.

@user2485100 2014-06-05 05:16:09

unfortunately statics only work inside of structs, so that's why this pattern.

@Eonil 2014-06-05 05:24:45

My intention was that we don't have to use dispatch_once stuffs. I am betting on your style. :)

@Sam 2014-06-05 07:46:08

I like this solution, but is it thread-safe?

@Russell Borogove 2014-06-05 17:51:30

Isn't class within a class declaration the equivalent of static in a struct declaration?

@Rob 2015-02-13 22:39:48

@Sam Yes it is. See the Apple blog entry on Files and Initialization which makes it clear that both globals and static members of structs and enums benefit from this dispatch_once capability.

@Kemal Can Kaynak 2015-11-17 13:59:00

final class MySingleton {
     private init() {}
     static let shared = MySingleton()
}

Then call it;

let shared = MySingleton.shared

@Rob 2016-11-11 09:16:18

Well done for not only marking init as private, but also for making the sharedMyModel as final! For the sake of future readers, in Swift 3, we might be inclined to rename sharedMyModel to be simply shared.

@Michael Morris 2017-04-16 14:47:23

This is the only correct answer, except that the override and call to super.init are erroneous and will not even compile.

@sleepwalkerfx 2016-09-27 15:21:01

From Apple Docs (Swift 3.0.1),

You can simply use a static type property, which is guaranteed to be lazily initialized only once, even when accessed across multiple threads simultaneously:

class Singleton {
    static let sharedInstance = Singleton()
}

If you need to perform additional setup beyond initialization, you can assign the result of the invocation of a closure to the global constant:

class Singleton {
    static let sharedInstance: Singleton = {
        let instance = Singleton()
        // setup code
        return instance
    }()
}

@Florian 2015-02-10 16:03:52

Swift 1.2 or later now supports static variables/constants in classes. So you can just use a static constant:

class MySingleton {

    static let sharedMySingleton = MySingleton()

    private init() {
        // ...
    }
}

@hpique 2014-06-10 17:57:53

tl;dr: Use the class constant approach if you are using Swift 1.2 or above and the nested struct approach if you need to support earlier versions.

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

Class constant

class Singleton  {
   static let sharedInstance = Singleton()
}

This approach supports lazy initialization because Swift lazily initializes class constants (and variables), and is thread safe by the definition of let. This is now officially recommended way to instantiate a singleton.

Class constants were introduced in Swift 1.2. If you need to support an earlier version of Swift, use the nested struct approach below or a global constant.

Nested struct

class Singleton {
    class var sharedInstance: Singleton {
        struct Static {
            static let instance: Singleton = Singleton()
        }
        return Static.instance
    }
}

Here we are using the static constant of a nested struct as a class constant. This is a workaround for the lack of static class constants in Swift 1.1 and earlier, and still works as a workaround for the lack of static constants and variables in functions.

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.

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!
    }
}

See this GitHub project for unit tests.

@jtbandes 2014-06-18 22:45:18

"thread safe by virtue of let" — has this been stated anywhere? I can't find mention of it in the documentation.

@hpique 2014-06-19 03:31:37

@jtbandes Constants are thread safe in all the languages I know.

@hpique 2014-06-22 15:30:25

@DaveWood I assume you're talking about the last approach. I'll quote myself: "I'd say it's no longer necessary to use this approach but I'm putting it here anyway as I find the differences in syntax interesting."

@Dave Wood 2014-06-22 16:13:46

@hpique jtbandes asked about thread safety being mentioned in the docs. That quote above was from one of the Swift devs, so I thought it would be helpful, and almost as good as documentation. I also thought the fact that globals and statics use dispatch_once under the hood was interesting. I was originally using the dispatch_once method myself and have now switched to the nested struct approach.

@hpique 2014-06-23 12:42:46

@DaveWood Thanks for clarifying. I thought you were replying to me.

@Joseph Duffy 2014-07-23 21:47:40

With the new access modifiers, is the first method now the "best"?

@hpique 2014-07-24 00:18:26

@JosephDuffy I still prefer the nested struct approach, as it limits the scope of the instance variable. Once class constants are supported, I will use those instead.

@user2727195 2014-12-15 03:55:35

great example @hpique, any approach for multiton please en.wikipedia.org/wiki/Multiton_pattern

@Frédéric Adda 2015-02-11 13:02:39

Do you know if XCode 6.3 brings something new to this subject ? Can we now use static properties in classes for singletons ?

@Dschee 2015-02-15 15:13:09

I have updated the project from @hpique to reflect the changes introduced with Swift 1.2, you can find my fork here: github.com/Dschee/SwiftSingleton

@hpique 2015-02-19 23:13:30

@FredA. Updated for Swift 1.2

@Stuart 2015-02-25 12:33:45

@hpique Why not just use static let sharedInstance = Singleton() in your "Class constant" approach? static properties in classes have global storage and are lazily initialised on first access, so you needn't declare your own storage and use a computed class variable (as of Swift 1.2).

@confile 2015-04-21 22:08:23

@hpique In your dispatch_once example will the Singleton class be lazily initialized?

@Andrew 2015-05-26 21:53:31

Should init be also be declared private to guarantee one and only one instance of the object will ever exist throughout the app's lifetime?

@hujunfeng 2015-07-22 03:50:46

Apple has documented the "Class constant" approach: developer.apple.com/library/prerelease/ios/documentation/Swi‌​ft/…

@David James 2015-08-07 09:39:09

Agree with Andrew, example should include private init to be a complete implementation. See also Florian's answer.

@malhal 2015-12-01 05:32:46

what about inheritance

@hyouuu 2016-05-20 07:23:08

With the static let approach, is there a way to make sure the instance is only initiated on main thread?

@Rob 2016-09-22 01:07:04

In the "Class constant" approach, I'd suggest (a) declaring the class to be final so you don't subclass it; and (b) declaring the init method to be private so that you can't accidentally instantiate another instance somewhere.

@Honey 2017-01-04 03:54:03

In your unit tests, what how are you testing thread_safety using func testSharedInstance_ThreadSafety()? You expect the 2 instances to be identical if you do what exactly? How are they different from the tests of testSharedInstance_Twice()?

@Ruben Marin 2017-03-02 15:07:46

What @Andrew and others claim is that in the "Class constant" implementation it is recommended to add private init() {} to prevent others from using the default '()' initializer for this class. Please check the end of this document: krakendev.io/blog/the-right-way-to-write-a-singleton

@Prashant Bhayani 2018-09-19 07:57:16

also make private init()

@Mike 2016-07-12 09:28:15

private var sharedURLCacheForRequestsKey:Void?
extension URLCache{
public static func sharedURLCacheForRequests()->URLCache{
    var cache = objc_getAssociatedObject(OperationQueue.main, &sharedURLCacheForRequestsKey)
    if cache is URLCache {

    }else{
        cache = URLCache(memoryCapacity: 0, diskCapacity: 1*1024*1024*1024, diskPath: "sharedURLCacheForRequestsKey")
        objc_setAssociatedObject(OperationQueue.main, &sharedURLCacheForRequestsKey, cache, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)

    }
    return cache as! URLCache
}}

@onmyway133 2016-01-25 15:47:17

In brief,

class Manager {
    static let sharedInstance = Manager()
    private init() {}
}

You may want to read Files and Initialization

The lazy initializer for a global variable (also for static members of structs and enums) is run the first time that global is accessed, and is launched as dispatch_once to make sure that the initialization is atomic.

@Nicolas Manzini 2014-08-24 17:33:54

First solution

let SocketManager = SocketManagerSingleton();

class SocketManagerSingleton {

}

Later in your code:

func someFunction() {        
    var socketManager = SocketManager        
}

Second solution

func SocketManager() -> SocketManagerSingleton {
    return _SocketManager
}
let _SocketManager = SocketManagerSingleton();

class SocketManagerSingleton {

}

And later in your code you will be able to keep braces for less confusion:

func someFunction() {        
    var socketManager = SocketManager()        
}

@Yedidya Reiss 2015-12-28 10:04:37

This is my implementation. It also prevents the programmer from creating a new instance:

let TEST = Test()

class Test {

    private init() {
        // This is a private (!) constructor
    }
}

@Martin R 2015-12-28 10:29:07

private init was already suggested here: stackoverflow.com/a/28436202/1187415.

@Adrian Macneil 2015-09-18 07:31:03

Per the Apple documentation, it has been repeated many times that the easiest way to do this in Swift is with a static type property:

class Singleton {
    static let sharedInstance = Singleton()
}

However, if you're looking for a way to perform additional setup beyond a simple constructor call, the secret is to use an immediately invoked closure:

class Singleton {
    static let sharedInstance: Singleton = {
        let instance = Singleton()
        // setup code
        return instance
    }()
}

This is guaranteed to be thread-safe and lazily initialized only once.

@gpichler 2015-11-20 14:15:33

how can you set the static let instance back to nil?

@Rob 2016-09-22 01:11:45

@user1463853 - You can't, and generally shouldn't.

@Jack 2014-06-03 20:55:41

For Swift 1.2 and beyond:

class Singleton  {
   static let sharedInstance = Singleton()
}

With a proof of correctness (all credit goes here), there is little to no reason now to use any of the previous methods for singletons.

Update: This is now the official way to define singletons as described in the official docs!

As for concerns on using static vs class. static should be the one to use even when class variables become available. Singletons are not meant to be subclassed since that would result in multiple instances of the base singleton. Using static enforces this in a beautiful, Swifty way.

For Swift 1.0 and 1.1:

With the recent changes in Swift, mostly new access control methods, I am now leaning towards the cleaner way of using a global variable for singletons.

private let _singletonInstance = SingletonClass()
class SingletonClass {
  class var sharedInstance: SingletonClass {
    return _singletonInstance
  }
}

As mentioned in the Swift blog article here:

The lazy initializer for a global variable (also for static members of structs and enums) is run the first time that global is accessed, and is launched as dispatch_once to make sure that the initialization is atomic. This enables a cool way to use dispatch_once in your code: just declare a global variable with an initializer and mark it private.

This way of creating a singleton is thread safe, fast, lazy, and also bridged to ObjC for free.

@nschum 2014-06-04 23:23:07

Anyone reading only this answer: Remember to make the token static, otherwise the behavior is undefined. See David's edited question for the complete code.

@Michael 2014-06-10 10:54:49

@nschum otherwise, the behaviour is not undefined, it is just broken in a well-defined way: the block will always execute.

@nschum 2014-06-10 17:56:34

@Michael: The documentation states it is undefined. The current behavior is therefore coincidental.

@Michael 2014-06-10 19:46:36

@nschum no offence, but I wouldn't believe everything that the documentation says. for dispatch_once to behave differently in static and non-static contexts it would need to check the memory layout to see if the token is static or not. that would be pretty unusual... but anyhow, I agree that it doesn't make sense to use a non-static dispatch_once token.

@nschum 2014-06-11 13:42:13

That's an odd thing to say. If the documentation calls it "undefined" that just means whoever wrote the code doesn't make any promises to what it does. It has nothing to do with the code knowing if the variable is static. It just means that the current (or apparent) behavior cannot not be relied upon.

@nschum 2014-06-11 13:42:53

And as why the behavior has been deemed undefined: stackoverflow.com/a/19845164/168939 Apparently the memory can't ever have been non-zero, and non-static memory is eventually recycled.

@CouchDeveloper 2014-09-13 07:35:39

Regarding your Edit: to reason that this construct is "thread safe" since the documentations says that the "initialization is atomic" is not justified. Atomicity is not sufficient for thread-safety. It additionally requires that all code wrapped in the dispatch_once block uses appropriate memory barriers so that all side effects on memory will be "published" to all other threads.

@rintaro 2014-09-24 07:38:05

You might want to add private init() {} as initialiser of SingletonClass. to prevent instantiate from outside.

@Rob 2016-09-22 01:08:17

... and, adding to rintaro's observation, declaring the class to be final so you don't accidentally subclass it.

@Jonny 2017-03-21 02:57:41

@rintaro 's way won't work without override keyword, and it has to call super init?

@DD.amor 2015-01-27 07:44:38

   func init() -> ClassA {
    struct Static {
        static var onceToken : dispatch_once_t = 0
        static var instance : ClassA? = nil
    }

    dispatch_once(&Static.onceToken) {
        Static.instance = ClassA()
    }

    return Static.instance!
}

@David Berry 2015-01-27 16:00:00

As has been discussed at great length here, it's not necessary in swift to wrap initialization in dispatch_once since static variable initialization is lazy and automatically protected via dispatch_once Apple actually recommends using statics instead of dispatch_once for that reason.

@David Berry 2014-06-06 01:58:59

Since Apple has now clarified that static struct variables are initialized both lazy and wrapped in dispatch_once (see the note at the end of the post), I think my final solution is going to be:

class WithSingleton {
    class var sharedInstance :WithSingleton {
        struct Singleton {
            static let instance = WithSingleton()
        }

        return Singleton.instance
    }
}

This takes advantage of the automatic lazy, thread-safe initialization of static struct elements, safely hides the actual implementation from the consumer, keeps everything compactly compartmentalized for legibility, and eliminates a visible global variable.

Apple has clarified that lazy initializer are thread-safe, so there's no need for dispatch_once or similar protections

The lazy initializer for a global variable (also for static members of structs and enums) is run the first time that global is accessed, and is launched as dispatch_once to make sure that the initialization is atomic. This enables a cool way to use dispatch_once in your code: just declare a global variable with an initializer and mark it private.

From here

@Bill 2014-06-06 12:15:26

To confirm: global variables have lazy, thread-safe initialization, but class variables don't. Right?

@Pascal Bourque 2014-09-26 19:03:16

I would add that a good practice would be to declare the initializer as private: private init() {}, to further enforce the fact that this class is not meant to be externally instantiated.

@user3610227 2014-12-31 00:27:00

so static struct var initialization is lazy and thread safe, what if that static struct var is a dictionary for multitons, then we have to manually synchronize/queue calls to it for each access, right?

@David Berry 2014-12-31 22:35:15

If I understand your question correctly, dictionary and array accesses are not inherently thread-safe, so you will need to use some form of thread synchronization.

@Ameet Dhas 2015-09-08 11:53:46

@DavidBerry How should I call a function inside this singleton class? I need a function to be called on the first call of myClass.sharedInstance.

@David Berry 2015-09-08 14:18:53

The easiest way is probably to use the compound initializer: static let instance : WithSingleton = { let singleton = WithSingleton() ; <your code here> ; return singleton }()

@user2737730 2014-07-24 09:57:24

My way of implementation in Swift...

ConfigurationManager.swift

import Foundation

    let ConfigurationManagerSharedInstance = ConfigurationManager()
 class ConfigurationManager : NSObject {
    var globalDic: NSMutableDictionary = NSMutableDictionary()

class var sharedInstance:ConfigurationManager {
    return ConfigurationManagerSharedInstance

}

init() {

    super.init()

    println ("Config Init been Initiated, this will be called only onece irrespective of many calls")   

}

Access the globalDic from any screen of the application by the below.

Read:

 println(ConfigurationManager.sharedInstance.globalDic)  

Write:

 ConfigurationManager.sharedInstance.globalDic = tmpDic // tmpDict is any value that to be shared among the application

@SchoonSauce 2014-06-26 20:04:02

Just for reference, here is an example Singleton implementation of Jack Wu/hpique's Nested Struct implementation. The implementation also shows how archiving could work, as well as some accompanying functions. I couldn't find this complete of an example, so hopefully this helps somebody!

import Foundation

class ItemStore: NSObject {

    class var sharedStore : ItemStore {
        struct Singleton {
            // lazily initiated, thread-safe from "let"
            static let instance = ItemStore()
        }
        return Singleton.instance
    }

    var _privateItems = Item[]()
    // The allItems property can't be changed by other objects
    var allItems: Item[] {
        return _privateItems
    }

    init() {
        super.init()
        let path = itemArchivePath
        // Returns "nil" if there is no file at the path
        let unarchivedItems : AnyObject! = NSKeyedUnarchiver.unarchiveObjectWithFile(path)

        // If there were archived items saved, set _privateItems for the shared store equal to that
        if unarchivedItems {
            _privateItems = unarchivedItems as Array<Item>
        } 

        delayOnMainQueueFor(numberOfSeconds: 0.1, action: {
            assert(self === ItemStore.sharedStore, "Only one instance of ItemStore allowed!")
        })
    }

    func createItem() -> Item {
        let item = Item.randomItem()
        _privateItems.append(item)
        return item
    }

    func removeItem(item: Item) {
        for (index, element) in enumerate(_privateItems) {
            if element === item {
                _privateItems.removeAtIndex(index)
                // Delete an items image from the image store when the item is 
                // getting deleted
                ImageStore.sharedStore.deleteImageForKey(item.itemKey)
            }
        }
    }

    func moveItemAtIndex(fromIndex: Int, toIndex: Int) {
        _privateItems.moveObjectAtIndex(fromIndex, toIndex: toIndex)
    }

    var itemArchivePath: String {
        // Create a filepath for archiving
        let documentDirectories = NSSearchPathForDirectoriesInDomains(NSSearchPathDirectory.DocumentDirectory, NSSearchPathDomainMask.UserDomainMask, true)
        // Get the one document directory from that list
        let documentDirectory = documentDirectories[0] as String
        // append with the items.archive file name, then return
        return documentDirectory.stringByAppendingPathComponent("items.archive")
    }

    func saveChanges() -> Bool {
        let path = itemArchivePath
        // Return "true" on success
        return NSKeyedArchiver.archiveRootObject(_privateItems, toFile: path)
    }
}

And if you didn't recognize some of those functions, here is a little living Swift utility file I've been using:

import Foundation
import UIKit

typealias completionBlock = () -> ()

extension Array {
    func contains(#object:AnyObject) -> Bool {
        return self.bridgeToObjectiveC().containsObject(object)
    }

    func indexOf(#object:AnyObject) -> Int {
        return self.bridgeToObjectiveC().indexOfObject(object)
    }

    mutating func moveObjectAtIndex(fromIndex: Int, toIndex: Int) {
        if ((fromIndex == toIndex) || (fromIndex > self.count) ||
            (toIndex > self.count)) {
                return
        }
        // Get object being moved so it can be re-inserted
        let object = self[fromIndex]

        // Remove object from array
        self.removeAtIndex(fromIndex)

        // Insert object in array at new location
        self.insert(object, atIndex: toIndex)
    }
}

func delayOnMainQueueFor(numberOfSeconds delay:Double, action closure:()->()) {
    dispatch_after(
        dispatch_time(
            DISPATCH_TIME_NOW,
            Int64(delay * Double(NSEC_PER_SEC))
        ),
        dispatch_get_main_queue()) {
            closure()
    }
}

@Howard Lovatt 2014-06-20 00:56:52

I would suggest an Enum, like you would use in Java, e.g.:

enum SharedTPScopeManager: TPScopeManager {
  case Singleton
}

@Bryan Chen 2014-06-30 23:08:15

IMO, this is the only correct Swift way to implement Singleton. other answers are ObjC/C/C++ way

@Kenny Winker 2014-07-06 01:57:12

Could you elaborate on this answer? It's not clear to me where Singleton is instantiated from this snippet

@Howard Lovatt 2014-07-07 03:04:44

@KennyWinker I don't have an Apple developer login, therefore no swift and so I can't answer when the initialisation occurs. In Java, it is on first use. Perhaps you could try it with a print on initialization and see if the print occurs at launch or after access. It will depend on how enum is implemented by the compiler.

@Howard Lovatt 2014-08-04 05:11:40

@KennyWinkler: Apple have just clarified how this works, see developer.apple.com/swift/blog/?id=7. In it they say "run the initializer for a global the first time it is referenced, similar to Java" and in particular. They also say that under the covers they are using "dispatch_once to make sure that the initialization is atomic". Therefore enum is almost certainly the way to go unless you have some fancy init to do, then a private static let is the solution.

@Michael 2014-06-15 16:28:40

If you are planning on using your Swift singleton class in Objective-C, this setup will have the compiler generate appropriate Objective-C-like header(s):

class func sharedStore() -> ImageStore {
struct Static {
    static let instance : ImageStore = ImageStore()
    }
    return Static.instance
}

Then in Objective-C class you can call your singleton the way you did it in pre-Swift days:

[ImageStore sharedStore];

This is just my simple implementation.

@Leslie Godwin 2015-11-03 05:31:00

This is actually more concise & correct than the other example because it is implemented the same way as other Swift singletons are. i.e: as class functions like NSFileManager.defaultManager(), but still uses the lazy thread-safe static member mechanisms of Swift.

@Rob 2016-09-22 01:12:54

Cocoa generally implements these as static properties, nowadays, not as class functions.

@Michael 2016-09-23 19:50:09

I am aware of that, my comment is over 2 years old. Thanks for mentioning.

@Viktor Radchenko 2014-06-11 23:16:58

I prefer this implementation:

class APIClient {

}

var sharedAPIClient: APIClient = {
    return APIClient()
}()

extension APIClient {
    class func sharedClient() -> APIClient {
        return sharedAPIClient
    }
}

Related Questions

Sponsored Content

17 Answered Questions

[SOLVED] How do I call Objective-C code from Swift?

  • 2014-06-02 20:05:42
  • David Mulder
  • 269855 View
  • 927 Score
  • 17 Answer
  • Tags:   objective-c swift

21 Answered Questions

[SOLVED] Creating a singleton in Python

36 Answered Questions

[SOLVED] What is so bad about singletons?

19 Answered Questions

[SOLVED] #pragma mark in Swift?

  • 2014-06-03 14:05:56
  • Arbitur
  • 210681 View
  • 901 Score
  • 19 Answer
  • Tags:   swift

9 Answered Questions

36 Answered Questions

[SOLVED] Difference between static class and singleton pattern?

18 Answered Questions

[SOLVED] C++ Singleton design pattern

29 Answered Questions

[SOLVED] What is an efficient way to implement a singleton pattern in Java?

0 Answered Questions

Singleton getinstance() method with void as return type

  • 2018-08-17 09:38:21
  • PARTHASARATHI S
  • 95 View
  • 0 Score
  • 0 Answer
  • Tags:   singleton

4 Answered Questions

[SOLVED] How to Create Singleton Object in swift

  • 2015-06-24 17:09:15
  • user4790024
  • 18114 View
  • 18 Score
  • 4 Answer
  • Tags:   ios swift singleton

Sponsored Content