Using a dispatch once singleton model in Swift

Question

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

User · Answer

I would suggest an enum  as you would use in Java  e g   enum SharedTPScopeManager  TPScopeManager       case Singleton

User · Answer

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 lt Item gt                      delayOnMainQueueFor numberOfSeconds  0 1  action                assert self     ItemStore sharedStore   Only one instance of ItemStore allowed                          func createItem   - gt  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   - gt  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      - gt      extension Array       func contains  object AnyObject  - gt  Bool           return self bridgeToObjectiveC   containsObject object             func indexOf  object AnyObject  - gt  Int           return self bridgeToObjectiveC   indexOfObject object             mutating func moveObjectAtIndex fromIndex  Int  toIndex  Int            if   fromIndex    toIndex      fromIndex  gt  self count                  toIndex  gt  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   - gt           dispatch after          dispatch time              DISPATCH TIME NOW              Int64 delay   Double NSEC PER SEC                      dispatch get main queue                  closure

User · Answer

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

User · Answer

func init   - gt  ClassA       struct Static           static var onceToken   dispatch once t   0         static var instance   ClassA    nil            dispatch once  amp Static onceToken            Static instance   ClassA              return Static instance

User · Answer

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

User · Answer

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   - gt  Singleton           return sharedInstanceVar           public class SubSingleton  Singleton        private static var sharedInstanceToken  dispatch once t   0      public class override func sharedInstance   - gt  SubSingleton           dispatch once  amp 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

User · Answer

I prefer this implementation   class APIClient       var sharedAPIClient  APIClient         return APIClient        extension APIClient       class func sharedClient   - gt  APIClient           return sharedAPIClient

User · Answer

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   - gt  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

User · Answer

Swift singletons are exposed in the Cocoa frameworks as class functions  e g  NSFileManager defaultManager    NSNotificationCenter defaultCenter    So it makes more sense as a class function to mirror this behavior  rather than a class variable as some other solutions  e g   class MyClass        private static let  sharedInstance   MyClass        class func sharedInstance   - gt  MyClass           return  sharedInstance           Retrieve the singleton via MyClass sharedInstance

User · Answer

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  amp Static onceToken                Static instance   Singleton                     return Static instance            See this GitHub project for unit tests

User · Answer

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   - gt  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

User · Answer

Swift 5 2 You can point to the type with Self  So  static let shared   Self    And should be inside a type  like  class SomeTypeWithASingletonInstance      static let shared   Self

User · Answer

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

User · Answer

Swift 4   protocol Singleton  class       static var sharedInstance  Self   get      final class Kraken  Singleton       static let sharedInstance   Kraken       private init

User · Answer

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

User · Answer

There is a better way to do it  You can declare a global variable in your class above the class declaration like this   var tpScopeManagerSharedInstance   TPScopeManager     This just calls your default init or whichever init and global variables are dispatch once by default in Swift  Then in whichever class you want to get a reference  you just do this   var refrence   tpScopeManagerSharedInstance    or you can just access properties and call methods directly tpScopeManagerSharedInstance someMethod     So basically you can get rid of the entire block of shared instance code

User · Answer

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

User · Answer

After seeing David s implementation  it seems like there is 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

User · Answer

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

User · Answer

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   - gt  RankMapping       return StaticRank shared    class var shared RankMapping       return StaticRank shared

User · Answer

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

User · Answer

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

User · Answer

I use the following syntax   public final class Singleton           private class func sharedInstance   - gt  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 has several advantages    Reminds the user not to subclass implementation Prevents creation of additional instances Ensures lazy creation and unique instantiation Shortens syntax  avoids     by allowing to access instance as Singleton instance

User · Answer

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

User · Answer

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  amp Static token                    Static instance   UtilSingleton                              return Static instance                      How to use   UtilSingleton shareInstance iVal   println  singleton new iVal     UtilSingleton shareInstance iVal

User · Answer

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

User · Answer

final class MySingleton        private init           static let shared   MySingleton       Then call it   let shared   MySingleton shared

User · Answer

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

User · Answer

First solution  let SocketManager   SocketManagerSingleton     class SocketManagerSingleton        Later in your code   func someFunction                 var socketManager   SocketManager             Second solution  func SocketManager   - gt  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

User · Answer

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

[swift] Using a dispatch_once singleton model in Swift

Examples related to swift

Examples related to singleton

Examples related to dispatch