Tôi đang cố gắng tạo ra một mô hình singleton thích hợp để sử dụng trong Swift. Cho đến nay, tôi đã có thể có được một mô hình an toàn không có luồng hoạt động như:

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

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

        return Static.instance!
    }
}

Việc bao bọc cá thể đơn lẻ trong cấu trúc tĩnh sẽ cho phép một cá thể đơn lẻ không va chạm với các cá thể đơn lẻ mà không có các sơ đồ đặt tên phức tạp và nó sẽ làm cho mọi thứ khá riêng tư. Rõ ràng, mặc dù, mô hình này không an toàn chủ đề. Vì vậy, tôi đã cố gắng để thêm dispatch_oncevào toàn bộ:

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

Nhưng tôi gặp lỗi trình biên dịch trên dispatch_oncedòng:

Không thể chuyển đổi loại 'Void' thành loại '()'

Tôi đã thử một số biến thể khác nhau của cú pháp, nhưng tất cả chúng đều có cùng kết quả:

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

Cách sử dụng thích hợp của dispatch_onceviệc sử dụng Swift là gì? Ban đầu tôi nghĩ vấn đề là do khối ()thông báo lỗi, nhưng càng nhìn vào nó, tôi càng nghĩ rằng đó có thể là vấn đề của việc dispatch_once_txác định chính xác.

tl; dr: Sử dụng cách tiếp cận hằng lớp nếu bạn đang sử dụng Swift 1.2 trở lên và cách tiếp cận cấu trúc lồng nhau nếu bạn cần hỗ trợ các phiên bản trước.

Từ kinh nghiệm của tôi với Swift, có ba cách tiếp cận để triển khai mẫu Singleton hỗ trợ khởi tạo lười biếng và an toàn luồng.

Lớp hằng

class Singleton  {
   static let sharedInstance = Singleton()
}

Cách tiếp cận này hỗ trợ khởi tạo lười biếng vì Swift lười biếng khởi tạo các hằng số lớp (và biến) và là luồng an toàn theo định nghĩa của let. Đây là cách chính thức được đề xuất để khởi tạo một singleton.

Các hằng số lớp được giới thiệu trong Swift 1.2. Nếu bạn cần hỗ trợ phiên bản Swift cũ hơn, hãy sử dụng phương pháp cấu trúc lồng nhau bên dưới hoặc hằng số toàn cầu.

Cấu trúc lồng nhau

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

Ở đây chúng ta đang sử dụng hằng số tĩnh của một cấu trúc lồng nhau như một hằng lớp. Đây là một cách giải quyết cho việc thiếu các hằng lớp tĩnh trong Swift 1.1 trở về trước và vẫn hoạt động như một cách giải quyết cho việc thiếu các hằng và biến tĩnh trong các hàm.

công văn

Cách tiếp cận Objective-C truyền thống được chuyển sang Swift. Tôi khá chắc chắn không có lợi thế so với cách tiếp cận cấu trúc lồng nhau nhưng dù sao tôi cũng đặt nó ở đây vì tôi thấy sự khác biệt trong cú pháp thú vị.

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

Xem dự án GitHub này để kiểm tra đơn vị.

Vì Apple hiện đã làm rõ rằng các biến cấu trúc tĩnh được khởi tạo cả lười biếng và được bao bọc dispatch_once(xem ghi chú ở cuối bài), tôi nghĩ rằng giải pháp cuối cùng của tôi sẽ là:

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

        return Singleton.instance
    }
}

Điều này tận dụng sự tự động lười biếng, khởi tạo an toàn luồng của các thành phần cấu trúc tĩnh, che giấu việc triển khai thực tế từ người tiêu dùng một cách an toàn, giữ mọi thứ được sắp xếp gọn gàng để dễ đọc và loại bỏ một biến toàn cục có thể nhìn thấy.

Apple đã làm rõ rằng trình khởi chạy lười biếng là an toàn cho luồng, do đó không cần dispatch_oncehoặc bảo vệ tương tự

Bộ khởi tạo lười biếng cho một biến toàn cục (cũng cho các thành viên tĩnh của structs và enums) được chạy lần đầu tiên khi toàn cầu được truy cập và được khởi chạy dưới dạng Clark_once để đảm bảo rằng việc khởi tạo là nguyên tử. Điều này cho phép một cách tuyệt vời để sử dụng Clark_once trong mã của bạn: chỉ cần khai báo một biến toàn cục bằng trình khởi tạo và đánh dấu nó ở chế độ riêng tư.

Từ đây

Dành cho Swift 1.2 trở lên:

class Singleton  {
   static let sharedInstance = Singleton()
}

Với một bằng chứng về tính chính xác (tất cả tín dụng ở đây ), hiện tại có rất ít lý do để sử dụng bất kỳ phương pháp nào trước đây cho singletons.

Cập nhật : Đây là cách chính thức để xác định singletons như được mô tả trong các tài liệu chính thức !

Đối với những lo ngại về việc sử dụng staticvs class. staticnên là một trong những để sử dụng ngay cả khi classcác biến có sẵn. Singletons không có nghĩa là được phân lớp vì điều đó sẽ dẫn đến nhiều trường hợp của singleton cơ sở. Sử dụngstatic thực thi điều này một cách đẹp đẽ, Swifty.

Đối với Swift 1.0 và 1.1:

Với những thay đổi gần đây trong Swift, chủ yếu là các phương thức kiểm soát truy cập mới, giờ đây tôi đang nghiêng về cách sử dụng biến toàn cục hơn cho singletons.

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

Như đã đề cập trong bài viết trên blog của Swift ở đây :

Bộ khởi tạo lười biếng cho một biến toàn cục (cũng cho các thành viên tĩnh của structs và enums) được chạy lần đầu tiên khi toàn cầu được truy cập và được khởi chạy dưới dạng Clark_once để đảm bảo rằng việc khởi tạo là nguyên tử. Điều này cho phép một cách tuyệt vời để sử dụng Clark_once trong mã của bạn: chỉ cần khai báo một biến toàn cục bằng trình khởi tạo và đánh dấu nó ở chế độ riêng tư.

Cách tạo singleton này là chủ đề an toàn, nhanh chóng, lười biếng và cũng được kết nối miễn phí với ObjC.

Swift 1.2 trở lên hiện hỗ trợ các biến / hằng tĩnh trong các lớp. Vì vậy, bạn chỉ có thể sử dụng một hằng số tĩnh:

class MySingleton {

    static let sharedMySingleton = MySingleton()

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

Có một cách tốt hơn để làm điều đó. Bạn có thể khai báo một biến toàn cục trong lớp của bạn trên khai báo lớp như thế này:

var tpScopeManagerSharedInstance = TPScopeManager()

Điều này chỉ gọi init mặc định của bạn hoặc bất kỳ biến init và biến toàn cục nào dispatch_oncetheo mặc định trong Swift. Sau đó, trong bất kỳ lớp học nào bạn muốn có được một tài liệu tham khảo, bạn chỉ cần làm điều này:

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

Vì vậy, về cơ bản, bạn có thể thoát khỏi toàn bộ khối mã cá thể được chia sẻ.

Swift singletons được đưa ra trong các khung công tác ca cao như các hàm lớp, ví dụ NSFileManager.defaultManager(), NSNotificationCenter.defaultCenter(). Vì vậy, nó có ý nghĩa hơn như là một hàm lớp để phản ánh hành vi này, chứ không phải là một biến lớp như một số giải pháp khác. ví dụ:

class MyClass {

    private static let _sharedInstance = MyClass()

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

Lấy singleton qua MyClass.sharedInstance().

Theo tài liệu của Apple , nhiều lần đã lặp đi lặp lại rằng cách dễ nhất để làm điều này trong Swift là với thuộc tính loại tĩnh:

class Singleton {
    static let sharedInstance = Singleton()
}

Tuy nhiên, nếu bạn đang tìm cách để thực hiện thiết lập bổ sung ngoài lệnh gọi hàm tạo đơn giản, thì bí mật là sử dụng một bao đóng được gọi ngay lập tức:

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

Điều này được đảm bảo là an toàn chủ đề và khởi tạo lười biếng chỉ một lần.

Swift 4+

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

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

Nhìn vào mã mẫu của Apple, tôi đã bắt gặp mẫu này. Tôi không chắc chắn cách Swift xử lý các số liệu thống kê, nhưng đây sẽ là chủ đề an toàn trong C #. Tôi bao gồm cả thuộc tính và phương thức cho interop Objective-C.

struct StaticRank {
    static let shared = RankMapping()
}

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

class var shared:RankMapping {
    return StaticRank.shared
}

Tóm lại,

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

Bạn có thể muốn đọc Tệp và Khởi tạo

Bộ khởi tạo lười biếng cho một biến toàn cục (cũng cho các thành viên tĩnh của structs và enums) được chạy lần đầu tiên khi toàn cầu được truy cập và được khởi chạy dispatch_onceđể đảm bảo rằng khởi tạo là nguyên tử.

Nếu bạn đang dự định sử dụng lớp đơn Swift của mình trong Objective-C, thiết lập này sẽ có trình biên dịch tạo (các) tiêu đề giống như Objective-C:

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

Sau đó, trong lớp Objective-C, bạn có thể gọi singleton của mình theo cách bạn đã làm trong những ngày trước Swift:

[ImageStore sharedStore];

Đây chỉ là thực hiện đơn giản của tôi.

Giải pháp đầu tiên

let SocketManager = SocketManagerSingleton();

class SocketManagerSingleton {

}

Sau đó trong mã của bạn:

func someFunction() {        
    var socketManager = SocketManager        
}

Giải pháp thứ hai

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

class SocketManagerSingleton {

}

Và sau này trong mã của bạn, bạn sẽ có thể giữ niềng răng để bớt nhầm lẫn:

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

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

Sau đó gọi nó;

let shared = MySingleton.shared

Sử dụng:

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

Cách sử dụng:

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

Cách tiếp cận tốt nhất trong Swift trên 1,2 là một dòng đơn, như -

class Shared: NSObject {

    static let sharedInstance = Shared()

    private override init() { }
}

Để biết thêm chi tiết về phương pháp này, bạn có thể truy cập liên kết này .

Từ Apple Docs (Swift 3.0.1),

Bạn chỉ có thể sử dụng một thuộc tính loại tĩnh, được đảm bảo chỉ được khởi tạo một cách lười biếng một lần, ngay cả khi được truy cập đồng thời trên nhiều luồng:

class Singleton {
    static let sharedInstance = Singleton()
}

Nếu bạn cần thực hiện thiết lập bổ sung ngoài khởi tạo, bạn có thể gán kết quả của lệnh gọi đóng cho hằng số toàn cục:

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

Tôi sẽ đề xuất một enum, như bạn sẽ sử dụng trong Java, vd

enum SharedTPScopeManager: TPScopeManager {
    case Singleton
}

Chỉ để tham khảo, đây là một ví dụ về triển khai Singleton của triển khai Nested Struct của Jack Wu / hpique. Việc thực hiện cũng cho thấy cách lưu trữ có thể hoạt động, cũng như một số chức năng đi kèm. Tôi không thể tìm thấy đầy đủ ví dụ này, vì vậy hy vọng điều này sẽ giúp được ai đó!

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

Và nếu bạn không nhận ra một số chức năng đó, thì đây là một tệp tiện ích Swift nhỏ mà tôi đang sử dụng:

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

Trong swift, bạn có thể tạo một lớp singleton theo cách sau:

class AppSingleton: NSObject {

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

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

Tôi thích thực hiện này:

class APIClient {

}

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

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

Cách triển khai của tôi trong Swift ...

Cấu hìnhQuản lý.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")   

}

Truy cập globalDic từ bất kỳ màn hình nào của ứng dụng bằng cách bên dưới.

Đọc:

 println(ConfigurationManager.sharedInstance.globalDic)  

Viết:

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

Cách tiếp cận đúng duy nhất là dưới đây.

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

    private init() {}
}

Truy cập vào

let signleton = Singleton.sharedInstance

Lý do:

• static loại thuộc tính được đảm bảo chỉ được khởi tạo một cách lười biếng một lần, ngay cả khi được truy cập đồng thời trên nhiều luồng, do đó không cần sử dụng dispatch_once
• Tư nhân hóa initphương thức để các thể khác không thể được tạo bởi các lớp khác.
• final lớp như bạn không muốn các lớp khác kế thừa lớp Singleton.

Sau khi thấy triển khai của David, có vẻ như không cần phải có chức năng lớp đơn instanceMethodvì letnó thực hiện khá giống với sharedInstancephương thức lớp. Tất cả bạn cần làm là tuyên bố nó là một hằng số toàn cầu và đó sẽ là nó.

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 để nhận ra singleton trong quá khứ, không có gì khác hơn là ba cách: biến toàn cục, biến nội bộ và cách Clark_once.

Dưới đây là hai singleton tốt (lưu ý: bất kể loại văn bản nào cũng phải chú ý đến phương thức riêng tư của init (). Bởi vì trong Swift, tất cả các hàm tạo của đối tượng là công khai, cần phải viết lại init có thể được chuyển thành riêng tư , ngăn các đối tượng khác của lớp này '()' theo phương thức khởi tạo mặc định để tạo đối tượng.)

Cách 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()

Cách 2:

class AppManager {
    static let sharedInstance = AppManager()

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

// How to use?
AppManager.sharedInstance

Đây là một trong những đơn giản nhất với khả năng an toàn chủ đề. Không có luồng nào khác có thể truy cập cùng một đối tượng singleton ngay cả khi họ muốn. 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!
        }
    }
}

Tôi yêu cầu singleton của tôi cho phép thừa kế, và không có giải pháp nào trong số này thực sự cho phép điều đó. Vì vậy, tôi đã đưa ra điều này:

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

• Cách này khi làm Singleton.sharedInstance()đầu tiên nó sẽ trả về thể hiện củaSingleton
• Khi làm SubSingleton.sharedInstance()đầu tiên, nó sẽ trả về thể hiện SubSingletonđã tạo.
• Nếu ở trên được thực hiện, sau đó SubSingleton.sharedInstance()là Singletonlà đúng và cùng một ví dụ được sử dụng.

Vấn đề với cách tiếp cận bẩn đầu tiên này là tôi không thể đảm bảo rằng các lớp con sẽ thực hiện dispatch_once_tvà đảm bảo rằng sharedInstanceVarnó chỉ được sửa đổi một lần cho mỗi lớp.

Tôi sẽ cố gắng tinh chỉnh điều này hơn nữa, nhưng sẽ rất thú vị để xem liệu có ai có cảm xúc mạnh mẽ với điều này không (ngoài thực tế là nó dài dòng và yêu cầu phải cập nhật thủ công).

Đây là thực hiện của tôi. Nó cũng ngăn lập trình viên tạo một thể hiện mới:

let TEST = Test()

class Test {

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

Tôi sử dụng cú pháp sau:

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

Điều này hoạt động từ Swift 1.2 lên đến 4 và có một số lợi thế:

1. Nhắc nhở người dùng không thực hiện lớp con
2. Ngăn chặn việc tạo các trường hợp bổ sung
3. Đảm bảo sự sáng tạo lười biếng và khởi tạo độc đáo
4. Rút ngắn cú pháp (tránh ()) bằng cách cho phép truy cập thể hiện như Singleton.instance