在Swift中使用dispatch_once单例模型

我正在努力制定一个合适的单例模型用于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() })

在Swift中dispatch_once的正确用法是什么?我最初认为问题出在错误消息中的()块上，但我看得越多，就越觉得可能是正确定义dispatch_once_t的问题。

当前回答

Swift单例在Cocoa框架中作为类函数公开，例如NSFileManager.defaultManager()， NSNotificationCenter.defaultCenter()。因此，作为一个类函数来反映这种行为比作为其他解决方案的类变量更有意义。例句:

class MyClass {

    private static let _sharedInstance = MyClass()

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

通过MyClass.sharedInstance()检索单例。

2015-01-13 03:36:32

其他回答

tl;dr:如果你使用的是Swift 1.2或更高版本，使用类常量方法;如果你需要支持更早的版本，使用嵌套结构方法。

根据我使用Swift的经验，有三种方法来实现支持延迟初始化和线程安全的单例模式。

类常量

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项目。

2014-06-10 17:57:53

我更喜欢这样的实现:

class APIClient {

}

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

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

2014-06-11 23:16:58

在查看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
}

2014-06-05 02:29:51

斯威夫特5.2

您可以用Self指向类型。所以:

static let shared = Self()

并且应该在一个类型中，比如:

class SomeTypeWithASingletonInstance {
   static let shared = Self()
}

2020-08-03 10:34:09

Swift过去实现单例，无非是三种方式:全局变量、内部变量和dispatch_once方式。

这里有两个不错的单品。(注:无论哪种写法都一定要注意init()私有化方法。因为在Swift中，所有对象的构造函数default都是public，需要重写init就可以变成private，防止该类的其他对象通过默认的初始化方法来创建对象。)

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

2018-01-03 07:19:26

在Swift中使用dispatch_once单例模型

推荐文章

最新文章

标签