Singleton Pattern - 单例模式

Singleton pattern：单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例类的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。

以上内容来自百度百科。

单例模式的基本思路：

---

1. 为单例对象实现一个静态实例，设置成 nil。
2. 调用时检查是否为 nil，是则创建否则直接使用。
3. 修改alloc等方法，预防被创建新实例。
4. 本质上，每次调用单例对象的实例方法，就只是创建了指针来指向该单例对象已经分配好的内存。

Objective - C 实现单例方法1

---

• 在 .h 文件中加入类工厂方法：

#import <Foundation/Foundation.h>

@interface SingletonGeekBand : NSObject

+(SingletonGeekBand *)shared;

@end

• 在 .m 文件中加入方法实现。

 #import "SingletonPattern.h"

// 建立静态变量
static SingletonPattern * shared = nil;

@implementation SingletonPattern

// 类工厂方法，如果 shared 还没初始化则初始化，否则直接调用
+ (SingletonPattern *)shared {
    // 确保单线程
    @synchronized(self) {
        if (shared == nil) {
            shared = [[self alloc] init];
        }
    }
    return shared;
}

// 重写 alloc 方法，确保不会被重新分配新的实例内存。
+(instancetype)alloc {
    @synchronized(self) {
        if (shared == nil) {
            shared = [super alloc];
            return shared;
        }
    }
    return shared;
}

// 重写 allocWithZone
+ (id)allocWithZone:(struct _NSZone *)zone {
    @synchronized(self) {
        if (shared == nil) {
            shared = [super allocWithZone:zone];
            return shared;
        }
    }
    return nil;
}

// 重写 copyWithZone
+ (id)copyWithZone:(NSZone *)zone {
    return self;
}

@end

Objective - C 实现单例方法2

---

• 在 .h 文件中加入类工厂方法：

#import <Foundation/Foundation.h>

@interface Singleton : NSObject

+ (instancetype) shareInstance;

@end

• 在 .m 文件中加入方法实现。

#import "Singleton.h"

@implementation Singleton

+ (instancetype) shareInstance {
    static dispatch_once_t dispatch = 0;
    static Singleton * instance;
    dispatch_once(&dispatch,^{
        instance = [[Singleton hiddenAlloc] init];
    });
    return instance;
}

+ (instancetype)alloc {
    return [self shareInstance];
}

+ (instancetype)hiddenAlloc {
    return [super alloc];
}

@end

Swift 实现单例

---

基本思路：

• 把下面类方法复制到要实现单例的类当中，并且将第1,4,7行的 ClassName 置换成类名称。

class func shareInstance() -> ClassName { // Change here!
    struct SingletonStruct {
        static var predicate: dispatch_once_t = 0
        static var instance: ClassName? = nil // Change here!
    }
    dispatch_once(&SingletonStruct.predicate, {
            SingletonStruct.instance = ClassName() // Change here!
        }
    )
    return SingletonStruct.instance!
}

例如我创建了一个继承自UIView的类，singletonView:

class SingletonView:UIView {
    class func shareInstance() -> SingletonView {
        struct SingletonStruct {
            static var predicate: dispatch_once_t = 0
            static var instance: SingletonView? = nil
        }
        dispatch_once(&SingletonStruct.predicate, {
            SingletonStruct.instance = SingletonView()
            }
        )
        return SingletonStruct.instance!
    }
}

• 在使用到的位置创建两个变量 testValueA，testValueB 通过 shareInstance 初始化并且调用。因为继承自UIView，所以我可以调用所有UIView的方法。而且，只要我改变了 testValue 当中的任何属性，testValueB 也会一起更改。
  注意单例在整个程序中只有一个，所以如果改变了其中一个变量的内容，那另一个变量也会随之改变。

var testValueA             = SingletonView.shareInstance()
testValueA.frame           = CGRectMake(0, 0, 100, 100)
testValueA.backgroundColor = UIColor.blueColor()
var testValueB             = SingletonView.shareInstance()
if testValueA == testValueB {
    print("YES")
}