我正在努力制定一个合适的单例模型用于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 1.2及以上版本:
class Singleton {
static let sharedInstance = Singleton()
}
有了正确性的证明(所有功劳都在这里)，现在几乎没有理由对单例对象使用任何前面的方法了。
更新:现在这是定义单例对象的官方方法，如官方文档中所述!
至于使用静态和类的问题。即使类变量可用，也应该使用静态变量。单例不应该被子类化，因为那样会导致基单例的多个实例。使用静态以一种漂亮的、Swifty的方式实现了这一点。
对于Swift 1.0和1.1:
随着Swift最近的变化，主要是新的访问控制方法，我现在倾向于对单例对象使用全局变量的更清洁的方式。
private let _singletonInstance = SingletonClass()
class SingletonClass {
class var sharedInstance: SingletonClass {
return _singletonInstance
}
}
正如Swift博客文章中提到的:
的静态成员的惰性初始化式
Structs和enum)在第一次访问global时运行，并且
作为dispatch_once启动，以确保初始化为
原子。这为在代码中使用dispatch_once提供了一种很酷的方式:
只需声明一个带有初始化式的全局变量并标记它
私有的。
这种创建单例的方式是线程安全的、快速的、懒惰的，而且还可以免费桥接到ObjC。
由于苹果现在已经澄清了静态结构变量是惰性初始化和包装在dispatch_once(见文章末尾的注释)，我认为我的最终解决方案将是:
class WithSingleton {
class var sharedInstance: WithSingleton {
struct Singleton {
static let instance = WithSingleton()
}
return Singleton.instance
}
}
这利用了静态结构元素的自动惰性、线程安全初始化，对使用者安全地隐藏了实际的实现，保持所有内容紧凑地分隔以使其易于阅读，并消除了可见的全局变量。
苹果已经澄清了惰性初始化器是线程安全的，所以不需要dispatch_once或类似的保护
全局变量(也包括struct和enum的静态成员)的惰性初始化器在第一次访问global时运行，并作为dispatch_once启动，以确保初始化是原子的。这为在代码中使用dispatch_once提供了一种很酷的方式:只需声明一个带有初始化式的全局变量并将其标记为private。
从这里
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项目。
这里有一个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()
}
}
我的实现方式在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
我要求我的单例允许继承，而这些解决方案实际上都不允许。所以我想到了这个:
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() is Singleton为true，并且使用相同的实例。
第一种脏方法的问题是，我不能保证子类会实现dispatch_once_t，并确保每个类只修改一次sharedInstanceVar。
我将尝试进一步完善它，但是看看是否有人对此有强烈的反对(除了它很冗长并且需要手动更新之外)，这将是很有趣的。
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
