Swiftでの使用に適したシングルトンモデルを作成しようとしています。これまでのところ、スレッドセーフでないモデルを次のように機能させることができました。

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

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

        return Static.instance!
    }
}

Static構造体でシングルトンインスタンスをラップすると、複雑な名前付けスキームなしでシングルトンインスタンスと衝突しない単一のインスタンスが許可され、かなりプライベートになるはずです。もちろん、このモデルはスレッドセーフではありません。だから私dispatch_onceは全部に追加しようとしました：

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

しかし、次のdispatch_once行でコンパイラエラーが発生します。

式のタイプ 'Void'をタイプ '（）'に変換できません

構文のさまざまなバリエーションを試しましたが、すべて同じ結果になるようです。

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

dispatch_onceSwiftを使用する適切な使用法は何ですか？最初()はエラーメッセージのに起因する問題がブロックにあると思っていましたが、よく見るほど、dispatch_once_t正しく定義することが問題になると思います。

tl; dr：Swift 1.2以降を使用している場合はクラス定数アプローチを使用し、以前のバージョンをサポートする必要がある場合はネストされた構造体アプローチを使用します。

Swiftでの私の経験から、遅延初期化とスレッドセーフをサポートするシングルトンパターンを実装する3つのアプローチがあります。

クラス定数

class Singleton  {
   static let sharedInstance = Singleton()
}

Swiftはクラス定数（および変数）を遅延初期化し、の定義によりスレッドセーフであるため、このアプローチは遅延初期化をサポートしますlet。これは現在、シングルトンをインスタンス化する方法として公式に推奨されています。

クラス定数はSwift 1.2で導入されました。Swiftの以前のバージョンをサポートする必要がある場合は、以下のネストされたstructアプローチまたはグローバル定数を使用してください。

ネストされた構造体

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

ここでは、ネストされた構造体の静的定数をクラス定数として使用しています。これは、Swift 1.1以前の静的クラス定数の欠如に対する回避策であり、関数に静的定数と変数の欠如に対する回避策として機能します。

dispatch_once

Swiftに移植された従来のObjective-Cアプローチ。ネストされた構造体のアプローチに勝る利点がないことはかなり確かですが、構文の違いが興味深いので、とにかくここに配置します。

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

単体テストについては、このGitHubプロジェクトを参照してください。

Appleが静的構造体変数が遅延初期化されてラップされることを明確にしたのでdispatch_once（投稿の最後の注を参照）、私の最終的な解決策は次のようになると思います：

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

        return Singleton.instance
    }
}

これは、静的なstruct要素の自動遅延およびスレッドセーフな初期化を利用し、実際の実装をコンシューマーから安全に隠し、すべてをコンパクトに区分けして読みやすくし、目に見えるグローバル変数を排除します。

Appleはレイジーイニシャライザーがスレッドセーフであることを明確にしたので、dispatch_onceまたは同様の保護は必要ありません

グローバル変数のレイジー初期化子（構造体と列挙型の静的メンバーも同様）は、最初にグローバルにアクセスしたときに実行され、dispatch_onceとして起動され、初期化がアトミックであることを確認します。これにより、コードでdispatch_onceを使用するクールな方法が可能になります。初期化子を使用してグローバル変数を宣言し、プライベートにマークするだけです。

ここから

Swift 1.2以降の場合：

class Singleton  {
   static let sharedInstance = Singleton()
}

正しさの証明（すべてのクレジットはここにあります）により、シングルトンに対して以前の方法のいずれかを使用する理由はほとんどありません。

更新：これは、公式ドキュメントで説明されているように、シングルトンを定義する公式の方法です。

staticvsの使用に関する懸念についてはclass。変数が使用可能になったstatic場合でも使用する必要がclassあります。シングルトンは、ベースシングルトンの複数のインスタンスが生成されるため、サブクラス化することを意図していません。を使用staticすると、これが美しく、迅速に実行されます。

Swift 1.0および1.1の場合：

Swiftの最近の変更、主に新しいアクセス制御メソッドにより、私は今、シングルトンにグローバル変数を使用するよりクリーンな方法に傾倒しています。

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

ここのSwiftブログ記事で述べたように：

グローバル変数のレイジー初期化子（構造体と列挙型の静的メンバーも同様）は、最初にグローバルにアクセスしたときに実行され、dispatch_onceとして起動され、初期化がアトミックであることを確認します。これにより、コードでdispatch_onceを使用するクールな方法が可能になります。初期化子を使用してグローバル変数を宣言し、プライベートにマークするだけです。

シングルトンを作成するこの方法は、スレッドセーフ、高速、遅延であり、無料でObjCにブリッジすることもできます。

Swift 1.2以降では、クラスの静的変数/定数がサポートされるようになりました。したがって、静的定数を使用することができます：

class MySingleton {

    static let sharedMySingleton = MySingleton()

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

それを行うためのより良い方法があります。次のように、クラス宣言の上のクラスでグローバル変数を宣言できます。

var tpScopeManagerSharedInstance = TPScopeManager()

これは、デフォルトのinit、またはdispatch_onceSwiftのデフォルトのinitおよびグローバル変数を呼び出すだけです。次に、参照を取得するクラスで、次のようにします。

var refrence = tpScopeManagerSharedInstance
// or you can just access properties and call methods directly
tpScopeManagerSharedInstance.someMethod()

したがって、基本的には共有インスタンスコードのブロック全体を取り除くことができます。

スウィフトのシングルトンは、クラスの機能、例えばとしてCocoaフレームワークで公開されていますNSFileManager.defaultManager()、NSNotificationCenter.defaultCenter()。したがって、他のいくつかのソリューションのようにクラス変数ではなく、クラスの関数としてこの動作をミラー化する方が理にかなっています。例えば：

class MyClass {

    private static let _sharedInstance = MyClass()

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

を介してシングルトンを取得しMyClass.sharedInstance()ます。

Appleのドキュメントによれば、Swiftでこれを行う最も簡単な方法は静的型プロパティを使用することです。

class Singleton {
    static let sharedInstance = Singleton()
}

ただし、単純なコンストラクター呼び出し以外の追加のセットアップを実行する方法を探している場合、秘密はすぐに呼び出されるクロージャーを使用することです。

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

これはスレッドセーフであることが保証されており、遅延初期化は1回だけです。

スウィフト4+

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

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

Appleのサンプルコードを見ると、このパターンに出くわしました。Swiftがstaticをどのように処理するかはわかりませんが、これはC＃ではスレッドセーフになります。Objective-C相互運用のプロパティとメソッドの両方を含めます。

struct StaticRank {
    static let shared = RankMapping()
}

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

class var shared:RankMapping {
    return StaticRank.shared
}

簡単に言えば、

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

ファイルと初期化を読むことをお勧めします

グローバル変数のレイジー初期化子（構造体と列挙型の静的メンバーも）は、最初にグローバルにアクセスしたときに実行されdispatch_once、初期化がアトミックであることを確認するために起動されます。

Objective-CでSwiftシングルトンクラスを使用することを計画している場合、この設定により、コンパイラーは適切なObjective-Cのようなヘッダーを生成します。

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

次に、Objective-Cクラスでは、Swift以前の時代と同じ方法でシングルトンを呼び出すことができます。

[ImageStore sharedStore];

これは私の単純な実装です。

最初の解決策

let SocketManager = SocketManagerSingleton();

class SocketManagerSingleton {

}

コードの後半：

func someFunction() {        
    var socketManager = SocketManager        
}

第二の解決策

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

class SocketManagerSingleton {

}

コードの後半では、混乱を少なくするために中括弧を付けることができます。

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

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

次に、それを呼び出します。

let shared = MySingleton.shared

使用する：

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

使い方：

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

1.2を超えるSwiftでの最良のアプローチは、1行のシングルトンです。

class Shared: NSObject {

    static let sharedInstance = Shared()

    private override init() { }
}

このアプローチの詳細については、こちらのリンクをご覧ください。

Apple Docs（Swift 3.0.1）から、

静的タイププロパティを使用するだけで、複数のスレッドに同時にアクセスした場合でも、1回だけ遅延して初期化されることが保証されます。

class Singleton {
    static let sharedInstance = Singleton()
}

初期化以外の追加のセットアップを実行する必要がある場合は、クロージャーの呼び出しの結果をグローバル定数に割り当てることができます。

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

私はお勧めしenumますが、Javaの、例えばで使用するように、

enum SharedTPScopeManager: TPScopeManager {
    case Singleton
}

参考までに、ここにJack Wu / hpiqueのNested Struct実装のシングルトン実装の例を示します。実装は、アーカイブがどのように機能するか、およびいくつかの付随する機能も示しています。私はこれの完全な例を見つけることができなかったので、うまくいけばこれが誰かを助けるでしょう！

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

そして、これらの機能の一部を認識しなかった場合は、ここで私が使用してきた生きているSwiftユーティリティファイルを少し示します。

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()
    }
}

迅速に、次の方法でシングルトンクラスを作成できます：

class AppSingleton: NSObject {

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

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

私はこの実装を好みます：

class APIClient {

}

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

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

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")   

}

以下の方法で、アプリケーションの任意の画面からglobalDicにアクセスします。

読んだ：

 println(ConfigurationManager.sharedInstance.globalDic)  

書く：

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

唯一正しい方法は以下のとおりです。

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

    private init() {}
}

アクセスするために

let signleton = Singleton.sharedInstance

理由：

• static typeプロパティは、複数のスレッドで同時にアクセスされた場合でも、1回だけ遅延して初期化されることが保証されているため、使用する必要はありません。 dispatch_once
• initメソッドをプライベート化して、インスタンスが他のクラスによって作成されないようにします。
• final 他のクラスがシングルトンクラスを継承しないようにするためです。

Davidの実装を見ると、クラスメソッドとほとんど同じことをしているinstanceMethodので、シングルトンクラス関数を持っている必要はないようです。必要なことは、それをグローバル定数として宣言することだけです。letsharedInstance

let gScopeManagerSharedInstance = ScopeManager()

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

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

過去にシングルトンを実現するためのSwiftは、グローバル変数、内部変数、およびdispatch_onceの3つの方法にすぎません。

ここに2つの良いシングルトンがあります（注：どんな種類の書き込みでも、プライベート化のinit（）メソッドに注意を払う必要があります.Swiftでは、オブジェクトのコンストラクターのデフォルトはすべてパブリックなので、書き換える必要がありますinitをプライベートに変えることができます、デフォルトの初期化メソッドによってこのクラス '（）'の他のオブジェクトがオブジェクトを作成するのを防ぎます。）

方法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()

方法2：

class AppManager {
    static let sharedInstance = AppManager()

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

// How to use?
AppManager.sharedInstance

これは、スレッドセーフ機能を備えた最も単純なものです。他のスレッドは、必要な場合でも同じシングルトンオブジェクトにアクセスできません。 スイフト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!
        }
    }
}

シングルトンに継承を許可するように要求しましたが、これらの解決策のいずれも実際には継承を許可していませんでした。だから私はこれを思いつきました：

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

• このように、Singleton.sharedInstance()最初に実行すると、インスタンスが返されますSingleton
• やったときSubSingleton.sharedInstance()最初にそれはのインスタンスを返しますSubSingleton作成します。
• 上記のようにすれば、その後SubSingleton.sharedInstance()さSingleton真であり、同じインスタンスが使用されます。

この最初のダーティなアプローチの問題は、サブクラスがを実装し、dispatch_once_tそれsharedInstanceVarがクラスごとに1回だけ変更されることを保証できないことです。

私はこれをさらに改良しようと試みますが、誰かがこれに対して強い感情を持っているかどうかを確認するのは興味深いことです（冗長であり、手動で更新する必要があるという事実以外に）。

これは私の実装です。また、プログラマが新しいインスタンスを作成するのを防ぎます。

let TEST = Test()

class Test {

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

次の構文を使用します。

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()
    }
}

これはSwift 1.2から4まで機能し、いくつかの利点があります。

1. 実装をサブクラス化しないようにユーザーに思い出させる
2. 追加のインスタンスの作成を防ぎます
3. 遅延作成と一意のインスタンス化を保証します
4. 次のようにインスタンスへのアクセスを許可することにより、構文を短縮します（（）を回避します） Singleton.instance