单例模式（Singleton）

单例模式是一种常见的设计模式，在 Cocoa 开发中也经常使用。

一个简单的单例模式示例代码如下：

1. /* Singleton.h */
2. #import "Foundation/Foundation.h"
3. @interface Singleton : NSObject
4. + (Singleton *)shardInstance;
5. @end

7. /* Singleton.m */
8. #import "Singleton.h"
9. static Singleton *instance = nil;

11. @implementation Singleton
12. + (Singleton *)sharedInstance {
13. if (!instance) {
14. instance = [[super allocWithZone:NULL] init];
15. }
16. return instance;
17. }

Cocoa 库本身在一些地方也使用了单例模式，例如[NSNotificationCenter defaultCenter]，[UIColor redColor]等。

这种写法的优点是，可以延迟加载，按需分配内存以节省开销。

但是，这并非一个线程安全的写法，比如两个或多个线程并发的调用 sharedInstance 方法，有可能会得到多个实例，这里列出两种方法来创建一个线程安全的单例。

@synchronized

可以使用@synchronized进行加锁，代码如下：

1. /* Singleton.h */
2. #import <Foundation/Foundation.h>
3. @interface Singleton : NSObject
4. + (Singleton *)sharedInstance;
5. @end
6. /* Singleton.m */
7. #import "Singleton.h"
8. static Singleton *instance = nil;
9. @implementation Singleton
10. + (Singleton *)sharedInstance {
11. @synchronized (self) {
12. if (!instance) {
13. instance = [[super alloc] init];
14. }
15. }
16. return instance;
17. }

这种写法也是懒加载，不过虽然保证了线程安全但是由于锁的存在当多线程访问时，性能会降低。

GCD

这里主要利用GCD中的dispatch_once方法，这是最普遍也是苹果最推荐的方法，函数原型如下：

1. void dispatch_once(
2. dispatch_once_t *predicate,
3. dispatch_block_t block);

单例实现代码如下：

1. /* Singleton.h */
2. #import <Foundation/Foundation.h>
3. @interface Singleton : NSObject
4. + (Singleton *)sharedInstance;
5. @end
6. /* Singleton.m */
7. #import "Singleton.h"
8. static Singleton *instance = nil;
9. @implementation Singleton
10. + (Singleton *)sharedInstance {
11. static dispatch_once_t predicate;
12. dispatch_once(&predicate, ^{
13. instance = [[Singleton alloc] init];
14. });
15. return instance;
16. }

这样的方法有很多优势，首先满足了线程安全问题，其次很好满足静态分析器要求。

GCD 可以确保以更快的方式完成这些检测，它可以保证 block 中的代码在任何线程通过 dispatch_once 调用之前被执行，但它不会强制每次调用这个函数都让代码进行同步控制。

苹果的文档 documentation for dispatch_once 是这么说的：

The predicate must point to a variable stored in global or static scope. The result of using a predicate with automatic or dynamic storage (including Objective-C instance variables) is undefined.

所以，如果你的 predicate 不是静态的、不是全局的，还是不能用GCD。其实如果去看这个函数所在的头文件，你会发现目前它的实现其实是一个宏。

工厂模式（Factory）

工厂模式是另一种常见的设计模式，本质上是使用方法来简化类的选择和初始化过程。

下面是一个网上到处都是的简单工厂模式的例子：

1. //
2. //  OperationFactory.m
3. //  FactoryPattern

5. #import "OperationFactory.h"
6. #import "Operation.h"
7. #import "OperationAdd.h"
8. #import "OperationSub.h"
9. #import "OperationMul.h"
10. #import "OperationDiv.h"

12. @implementation OperationFactory

14. + (Operation *) createOperat:(char)operate{
15. Operation *oper = nil;
16. switch (operate) {
17. case '+':
18. {
19. oper = [[OperationAdd alloc] init];
20. break;
21. }
22. case '-':
23. {
24. oper = [[OperationSub alloc] init];
25. break;
26. }
27. case '*':
28. {
29. oper = [[OperationMul alloc] init];
30. break;
31. }
32. case '/':
33. {
34. oper = [[OperationDiv alloc] init];
35. break;
36. }
37. default:
38. break;
39. }
40. return oper;
41. }
42. @end

由于 Objective-C 本身的动态特性，还可以用反射来改写：

1. @implementation OperationFactory
2. + (Operation *) createOperat:(NSString *)operate{
3. Operation *oper = nil;
4. Class class = NSClassFromString(operate);
5. oper = [(Operation *)[class alloc] init];
6. if ([oper respondsToSelector:@selector(getResult)]) {
7. [oper getResult];
8. }
9. return oper;
10. }
11. @end

使用时，可以传入类名，来获取对应类的对象：

1. Operation *oper = [OperationFactory createOperat: @"OperationAdd"];
2. oper.numberA = 10;
3. oper.numberB = 20;
4. NSLog(@"%f", oper.getResult);

委托模式（Delegate）

委托模式是 Cocoa 中十分常见的设计模式，在 Cocoa 库中被大量的使用。在 Objective-C 中，委托模式通常使用协议（protocol）来实现。

委托模式的示例代码：

1. @protocol PrintDelegate <NSObject>
2. - (void)print;
3. @end

6. @interface AClass : NSObject<PrintDelegate>
7. @property id<PrintDelegate> delegate;
8. @end

10. @implementation AClass

12. -(void)sayHello {
13. [self.delegate print];
14. }

16. -(void)print {
17. NSLog(@"Do Print");
18. }
19. @end

21. // 使用 AClass
22. int main(int argc, const char * argv[]) {
23. @autoreleasepool {
24. AClass * a = [AClass new];
25. a.delegate = a;
26. [a sayHello];
27. }
28. return 0;
29. }

这里对象a的 delegate 设置为自己，也可以是任何一个实现了 PrintDelegate 协议的对象。

观察者模式（Observer）

Cocoa 中提供了两种用于实现观察者模式的办法，一直是使用NSNotification，另一种是KVO(Key Value Observing)。

NSNotification

NSNotification 基于 Cocoa 自己的消息中心组件 NSNotificationCenter 实现。

观察者需要统一在消息中心注册，说明自己要观察哪些值的变化。观察者通过类似下面的函数来进行注册：

1. [[NSNotificationCenter defaultCenter] addObserver:self
2. selector:@selector(printName:)
3. name: @"messageName"
4. object:nil];

上面的函数表明把自身注册成 “messageName” 消息的观察者，当有消息时，会调用自己的 printName 方法。

消息发送者使用类似下面的函数发送消息：

1. [[NSNotificationCenter defaultCenter] postNotificationName:@"messageName"
2. object:nil
3. userInfo:nil];

KVO(Key Value Observing)

KVO的实现依赖于 Objective-C 本身强大的 KVC(Key Value Coding) 特性，可以实现对于某个属性变化的动态监测。

示例代码如下：

1. // Book类
2. @interface Book : NSObject

4. @property NSString *name;
5. @property CGFloat price;

7. @end

9. // AClass类
10. @class Book;
11. @interface AClass : NSObject

13. @property (strong) Book *book;

15. @end

17. @implementation AClass

19. - (id)init:(Book *)theBook {
20. if(self = [super init]){
21. self.book = theBook;
22. [self.book addObserver:self forKeyPath:@"price" options:NSKeyValueObservingOptionOld|NSKeyValueObservingOptionNew context:nil];
23. }
24. return self;
25. }

27. - (void)observeValueForKeyPath:(NSString *)keyPath
28. ofObject:(id)object
29. change:(NSDictionary *)change
30. context:(void *)context{
31. if([keyPath isEqual:@"price"]){
32. NSLog(@"------price is changed------");
33. NSLog(@"old price is %@",[change objectForKey:@"old"]);
34. NSLog(@"new price is %@",[change objectForKey:@"new"]);
35. }
36. }

38. - (void)dealloc{
39. [self.book removeObserver:self forKeyPath:@"price"];
40. }
41. @end

43. // 使用 KVO
44. int main(int argc, const char * argv[]) {
45. @autoreleasepool {
46. Book *aBook = [Book new];
47. aBook.price = 10.9;
48. AClass * a = [[AClass alloc] init:aBook];
49. aBook.price = 11; // 输出 price is changed
50. }
51. return 0;
52. }

参考资料