对于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。

我要求我的单例允许继承，而这些解决方案实际上都不允许。所以我想到了这个:

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。

我将尝试进一步完善它，但是看看是否有人对此有强烈的反对(除了它很冗长并且需要手动更新之外)，这将是很有趣的。

我使用以下语法:

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到Swift 4都可以使用，有几个优点:

提醒用户不要子类化实现 防止创建额外的实例 确保惰性创建和唯一实例化 通过允许以Singleton.instance的形式访问instance来缩短语法(avoid ())

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

我更喜欢这样的实现:

class APIClient {

}

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

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

有更好的办法。你可以像这样在你的类声明上面声明一个全局变量:

var tpScopeManagerSharedInstance = TPScopeManager()

这只是调用你的默认init或任何init和全局变量是dispatch_once在Swift默认。然后在任何你想要引用的类中，你只需要这样做:

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

所以基本上你可以去掉整个共享实例代码块。