Я намагаюся розробити відповідну однотонну модель для використання в Swift. Поки що мені вдалося отримати безпечну модель без потоку, яка працює як:

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

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

        return Static.instance!
    }
}

Обгортання одиночного екземпляра в статичну структуру повинно дозволяти одному екземпляру, який не стикається з одиночними екземплярами без складних схем іменування, і він повинен робити речі досить приватними. Очевидно, що ця модель не є безпечною для потоків. Тому я спробував додати 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 є три підходи до реалізації шаблону Singleton, який підтримує ледачу ініціалізацію та безпеку потоку.

Константа класу

class Singleton  {
   static let sharedInstance = Singleton()
}

Такий підхід підтримує ліниву ініціалізацію, оскільки Swift ліниво ініціалізує константи класу (та змінні) та є безпечним для потоків визначенням let. Зараз це офіційно рекомендований спосіб інстанції сингла.

Константи класу були введені в Swift 1.2. Якщо вам потрібно підтримати більш ранню версію Swift, використовуйте вкладений нижче підхід структури або глобальну константу.

Вкладена структура

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

Тут ми використовуємо статичну константу вкладеної структури як константа класу. Це рішення для відсутності констант статичних класів у Swift 1.1 та більш ранніх версіях, і досі працює як спосіб вирішення нестачі статичних констант та змінних у функціях.

dispatch_once

Традиційний підхід «Objective-C» був перенесений на Swift. Я впевнений, що немає переваги перед вкладеним структурним підходом, але я все-таки розміщую його тут, оскільки я вважаю відмінності в синтаксисі цікавими.

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

Це використовує автоматичну ледачу, безпечну для потоків ініціалізацію статичних елементів структури, безпечно приховує реальну реалізацію від споживача, зберігає все компактно розподілене для розбірливості та усуває видиму глобальну змінну.

Apple уточнила, що лінивий ініціалізатор захищений від потоку, тому немає необхідності в dispatch_onceподібних захистях

Лінивий ініціалізатор для глобальної змінної (також для статичних членів структур і перерахунків) запускається вперше, коли доступ до глобального доступу, і запускається як dispatch_once, щоб переконатися, що ініціалізація є атомною. Це дозволяє крутим способом використання dispatch_once у вашому коді: просто оголосіть глобальну змінну ініціалізатором та позначте її як приватну.

від сюди

Для Swift 1.2 і вище:

class Singleton  {
   static let sharedInstance = Singleton()
}

Маючи доказ коректності (вся заслуга тут ), мало використовувати будь-який з попередніх методів для одиночних нині.

Оновлення : тепер це офіційний спосіб визначення одиночних клавіш, як описано в офіційних документах !

Що стосується побоювань щодо використання staticпроти class. staticповинен використовуватись, навіть коли classзмінні стають доступними. Singleton не призначені для підкласів, оскільки це призведе до декількох примірників базового сингтона. Використанняstatic примушує це робити красивим, швидким способом.

Для Swift 1.0 та 1.1:

З останніми змінами в Swift, здебільшого новими методами контролю доступу, я зараз схиляюся до більш чистого способу використання глобальної змінної для одиночних клавіш.

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

Як згадується у статті про блог Свіфта тут :

Ледачий ініціалізатор для глобальної змінної (також для статичних членів структур і перерахунків) запускається вперше, коли доступ до глобального доступу, і запускається як dispatch_once, щоб переконатися, що ініціалізація є атомною. Це дозволяє крутим способом використання dispatch_once у вашому коді: просто оголосіть глобальну змінну ініціалізатором та позначте її як приватну.

Цей спосіб створення синглтона є безпечним, швидким, ледачим, а також з'єднується з ObjC безкоштовно.

Swift 1.2 або новіша версія тепер підтримує статичні змінні / константи в класах. Тож ви можете просто використовувати статичну константу:

class MySingleton {

    static let sharedMySingleton = MySingleton()

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

Є кращий спосіб це зробити. Ви можете оголосити глобальну змінну у своєму класі над декларацією класу так:

var tpScopeManagerSharedInstance = TPScopeManager()

Це просто викликає ваш init за замовчуванням або залежно від того, що init, а глобальні змінні dispatch_onceза замовчуванням є у Swift. Тоді в якому б класі ви хочете отримати довідку, ви просто зробите це:

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

Таким чином, ви можете позбутися всього блоку коду спільного екземпляра.

Swift одинаки піддаються в рамках какао в якості класу функцій, наприклад 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
    }()
}

Це гарантовано безпечно для потоків і ліниво ініціюється лише один раз.

Швидкий 4+

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

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

Дивлячись на зразок коду Apple, я натрапив на цю модель. Я не впевнений, як Swift має справу зі статикою, але це було б безпечно для потоків у 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щоб переконатися, що ініціалізація є атомною.

Якщо ви плануєте використовувати ваш клас Singleton Swift в Objective-C, у цьому налаштуванні компілятор буде генерувати відповідні заголовки, подібні Objective-C:

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

Тоді в класі Objective-C ви можете назвати сингтона так, як ви це робили в передшвидкі дні:

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

Найкращий підхід у Swift вище 1,2 - однолінійний однотонний, як -

class Shared: NSObject {

    static let sharedInstance = Shared()

    private override init() { }
}

Щоб дізнатися більше про цей підхід, ви можете відвідати це посилання .

Від Apple Docs (Swift 3.0.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. Впровадження також показує, як може працювати архівація, а також деякі супутні функції. Я не зміг знайти цей приклад, тому, сподіваюся, це допомагає комусь!

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 властивість типу гарантується, що ліниво ініціалізується лише один раз, навіть при доступі до декількох потоків одночасно, тому не потрібно використовувати dispatch_once
• Приватизація init методу, тому екземпляр не може бути створений іншими класами.
• final клас, оскільки ви не хочете, щоб інші класи успадкували клас Singleton.

Побачивши реалізацію Девіда, здається, що немає необхідності мати функцію класу однотонних, instanceMethodоскільки letце робить майже те саме, що і sharedInstanceметод класу. Все, що вам потрібно зробити - це оголосити це глобальною константою, і це було б все.

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

Швидко усвідомити синглтон в минулому - це не що інше, як три способи: глобальні змінні, внутрішні змінні та способи dispatch_once.

Ось два хороших синглтона. (Зауважте: незалежно від того, який тип письма повинен звернути увагу на метод 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це буде змінено лише один раз у класі.

Я спробую це ще більше уточнити, але було б цікаво побачити, чи є у когось сильні почуття проти цього (окрім того, що він є багатослівним і вимагає його вручну оновити).

Це моя реалізація. Це також заважає програмісту створити новий екземпляр:

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