根据苹果的文档，已经重复了很多次，在Swift中最简单的方法是使用静态类型属性:

class Singleton {
    static let sharedInstance = Singleton()
}

然而，如果你正在寻找一种方法来执行一个简单的构造函数调用之外的额外设置，秘密是使用一个立即调用的闭包:

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

这保证是线程安全的，并且只进行一次惰性初始化。

由于苹果现在已经澄清了静态结构变量是惰性初始化和包装在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。

从这里

斯威夫特5.2

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

static let shared = Self()

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

class SomeTypeWithASingletonInstance {
   static let shared = Self()
}

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

这是具有线程安全功能的最简单的一个。即使其他线程想要访问同一个单例对象，它们也不能访问。斯威夫特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!
        }
    }
}

我的实现方式在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