[设计模式]之三:单例模式

设计模式系列目录

需求情景

仍是试想一个情景：如今有一个自定义对话框。当主界面上的按钮被点击后，弹出对话框。
通常的设计思路是这样的：

- (void)onBtnClicked {
    MyPopupView *popup = [[MyPopupView alloc] init];
    [self.view addSubview: popup];
    [popup show];
}

假设这个对话框能够保存一些状态，好比上次输入的内容之类的信息，那咱们就须要保证这个实例惟一，也就是第一次使用的时候建立一次实例，以后都使用这个实例。

MyPopupView *popup;

- (void)onBtnClicked {
    if (nil == popup) {
        popup = [[MyPopupView alloc] init];
        [self.view addSubview: popup];
    }
    [popup show];
}

看到这里，应该就能发现，对于这个自定义的对话框，我每次调用的时候都要去判断我须要的实例是否存在。并且例子中逻辑判断很简单，真正写的时候状况也许会更复杂，这也就意味着我每次用它都要写不少重复的代码，而这些代码仅仅是为了保证这个类只有一个实例。

因此对于这类情形，最好能有一个办法让类自己去控制本身只有一个实例，而不是让调用者每次都操心它。

可是类都有一个构造方法，即便不写它也会有一个默认的构造方法供外部调用，像Java的话，能够直接将构造方法改成私有，不给外部new出实例。对于Objective-C彷佛并不能阻止你alloc一个实例对象，固然这并非关键。下面才是。

单例模式

单例模式，保证一个类仅有一个实例，并提供一个访问它的全局访问点

也就是说让类自身来负责保存它的惟一实例，保证没有其余实例被建立，而且提供一个访问该实例的方法。

因此关键点就是首先在类中建立一个静态全局变量，用来保存当前类的实例。而后建立一个获取该实例的类方法，在该方法中生成实例并保证其惟一便可。

///.h
@interface MyManager : NSObject {
  NSString *someProperty;
}

@property (nonatomic, retain) NSString *someProperty;

+ (instancetype)sharedManager;

@end
///.m
@implementation MyManager

@synthesize someProperty;

+ (instancetype)sharedManager {
  static MyManager *sharedMyManager = nil;
  if (nil == sharedMyManager)
    sharedMyManager = [[self alloc] init];
  return sharedMyManager;
}

- (instancetype)init {
  if (self = [super init]) {
    someProperty = @"Default Property Value";
  }
  return self;
}
@end
///main
MyManager *manager1 = [[MyManager alloc] init];
MyManager *manager2 = [MyManager sharedManager];
MyManager *manager3 = [MyManager sharedManager];
NSLog(@"manager1 %p", manager1);
NSLog(@"manager2 %p", manager2);
NSLog(@"manager3 %p", manager3);
NSLog(@"Instance property: %@", manager2.someProperty);
manager2.someProperty = @"Changed By manager2";
NSLog(@"Instance property: %@", manager3.someProperty);

经过程序，能够看到，建立了

static MyManager *sharedMyManager = nil;

来保存实例，而后使用

+ (instancetype)sharedManager

访问实例。

主程序输出为

manager1 0x100300080
manager2 0x1003000b0
manager3 0x1003000b0
Instance property: Default Property Value
Instance property: Changed By manager2

经过指针地址能够看到，当前类是能够经过alloc建立一个不一样实例，但经过sharedManager访问得到的实例是相同的，所以属性也是一致的。

UML类图

多线程时的单例

在多线程的状况下，上面的程序就没法保证明例的惟一性，多个线程同时访问MyManager类时，调用获取实例的方法就会建立出多个实例。
因此就要对代码加锁。这个原理就不讲了，操做系统都学过的。

+ (instancetype)sharedManager {
  static MyManager *sharedMyManager = nil;
  //使用GCD
  static dispatch_once_t onceToken;
  dispatch_once(&onceToken, ^{
    sharedMyManager = [[self alloc] init];
  });
  //非GCD
  @synchronized(self) {
    if (nil == sharedMyManager)
      sharedMyManager = [[self alloc] init];
  }
    return sharedMyManager;
}

Swift版本

class MyManager {
    static private var onceToken: dispatch_once_t = 0
    static private var sharedMyManager: MyManager? = nil
    static func sharedMyManager() -> MyManager {
        dispatch_once(&onceToken) {
            sharedMyManager = MyManager()
        }
        return sharedMyManager!
    }
    private init() {} //私有化构造方法  外部没法构造
}

let single1 = MyManager.sharedMyManager()
let single2 = MyManager.sharedMyManager()
unsafeAddressOf(single1)
unsafeAddressOf(single2)

单例模式的好处

• 能够保证惟一的实例
• 严格控制他人怎样访问与什么时候访问
• 方便共享状态

参考
Singletons in Objective-C