单例模式

1、单例模式的定义
单例模式确保一个类只有一个实例，并提供一个全局访问点。

2、使用场景
我们希望这个类在整个应用程序中，只有一个对象实例，并且提供一个全局访问接口。单例模式常常被用来管理共享的资源，例如，注册表信息，数据库连接或线程池等。对于全局共享的资源的访问，使用单例可以避免资源访问时数据的不一致问题。

3、单例模式的实现
1）单例模式在Java语言中的实现
对于Java的实现可以简单的概括为单例类没有公开的构造方法，外界不能自行实例化一个对象，只能通过通过这个单例类提供的静态接口方法获得该单例类的实例（单例类的实例化是在该类的内部完成的）。
这里给出两种实现。
其一：紧急加载型（饿汉式）

//在类初始化时，已经实例化对象   public class Singleton {      private Singleton() {}      private static final Singleton singleton = new Singleton();      public static Singleton getInstance() {          return singleton;      }  }  

其二：延迟加载型（懒汉式）

public class Singleton {private volatile static Singleton uniqueInstance;private Singleton() {}public static Singleton getInstance() {          if (uniqueInstance == null) {                synchronized (Singleton.class) {                   if (uniqueInstance == null) {                      uniqueInstance = new Singleton();                  }                }            }            return uniqueInstance;       }  }

这两种方法都能保证线程安全。饿汉式是在类创建的同时就已经创建好一个静态的对象可供使用，以后不再改变，所以是线程安全的。懒汉式使用了同步锁来保证线程安全，并且使用了双重检查加锁来减少同步的次数。

2）单例模式在Objective-C语言中的实现
先看一下苹果给的方案
Singleton
Singletons provide a globally accessible, shared instance of an object. You can create your own singletons as a way to provide a unified access point to a resource or service that’s shared across an app, such as an audio channel to play sound effects or a network manager to make HTTP requests.
In Objective-C, you can ensure that only one instance of a singleton object is created by wrapping its initialization in a call the dispatch_once function, which executes a block once and only once for the lifetime of an app:

        + (instancetype)sharedInstance {            static id _sharedInstance = nil;            static dispatch_once_t onceToken;            dispatch_once(&onceToken, ^{                _sharedInstance = [[self alloc] init];            });            return _sharedInstance;        }

In Swift, you can simply use a static type property, which is guaranteed to be lazily initialized only once, even when accessed across multiple threads simultaneously:

        class Singleton {            static let sharedInstance = Singleton()        }

If you need to perform additional setup beyond initialization, you can assign the result of the invocation of a closure to the global constant:

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

可以看出苹果的实现并不是一种严格的单例模式。如果通过[SomeClass alloc] init] 和 ［SomeClass sharedInstance] 的方式去获取对象，得到的就是不同的对象。如果你一直使用sharedInstance方法去获取对象的话，那么得到的就是同一个对象。例如系统的NSFileManager类就是这种情况。在实际的开发中，我们可能也使用这种简洁的方式。

对于Objective-C来说，实现一个“严格的单例”可能稍微复杂一些（需要重写的方法较多），不像Java或C++那样提供了很好的机制来实现这一模式。在ARC模式下，我们可以这样来实现：

+ (instancetype)shareInstance {    return [[self alloc] init];}static Singleton *_instance;+ (instancetype)allocWithZone:(struct _NSZone *)zone {    // 由于alloc方法内部会调用allocWithZone: 所以我们只需要保证在该方法只创建一个对象即可    static dispatch_once_t onceToken;    dispatch_once(&onceToken,  ^{        _instance = [super allocWithZone:zone];    });    return _instance;}- (id)copyWithZone:(NSZone *)zone {    return _instance;}- (id)mutableCopyWithZone:(NSZone *)zone {    return _instance;}

对于MRC来说，我们还要考虑引用计数内存模型，这个时候我们要重写于内存管理相关的方法。

+ (instancetype)shareInstance {    return [[self alloc] init];}static Singleton *_instance;+ (instancetype)allocWithZone:(struct _NSZone *)zone {    // 由于alloc方法内部会调用allocWithZone: 所以我们只需要保证在该方法只创建一个对象即可    static dispatch_once_t onceToken;    dispatch_once(&onceToken, ^{        _instance = [super allocWithZone:zone];    });    return _instance;}-  (id)copyWithZone:(NSZone *)zone {    // 因为copy方法必须通过实例对象调用, 所以可以直接返回_instance    return _instance;}-  (id)mutableCopyWithZone:(NSZone *)zone {    return _instance;}-  (oneway void)release {}-  (instancetype)retain {    return _instance;}-  (NSUInteger)retainCount {    return MAXFLOAT;}